defmodule RDF.DatasetTest do use RDF.Test.Case doctest RDF.Dataset describe "new" do test "creating an empty unnamed dataset" do assert unnamed_dataset?(unnamed_dataset()) end test "creating an empty dataset with a proper dataset name" do refute unnamed_dataset?(named_dataset()) assert named_dataset?(named_dataset()) end test "creating an empty dataset with a coercible dataset name" do assert named_dataset("http://example.com/DatasetName") |> named_dataset?(~I) assert named_dataset(EX.Foo) |> named_dataset?(iri(EX.Foo)) end test "creating an unnamed dataset with an initial triple" do ds = Dataset.new({EX.Subject, EX.predicate(), EX.Object}) assert unnamed_dataset?(ds) assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate(), EX.Object}) end test "creating an unnamed dataset with an initial quad" do ds = Dataset.new({EX.Subject, EX.predicate(), EX.Object, EX.GraphName}) assert unnamed_dataset?(ds) assert dataset_includes_statement?( ds, {EX.Subject, EX.predicate(), EX.Object, EX.GraphName} ) end test "creating a named dataset with an initial triple" do ds = Dataset.new({EX.Subject, EX.predicate(), EX.Object}, name: EX.DatasetName) assert named_dataset?(ds, iri(EX.DatasetName)) assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate(), EX.Object}) end test "creating a named dataset with an initial quad" do ds = Dataset.new({EX.Subject, EX.predicate(), EX.Object, EX.GraphName}, name: EX.DatasetName) assert named_dataset?(ds, iri(EX.DatasetName)) assert dataset_includes_statement?( ds, {EX.Subject, EX.predicate(), EX.Object, EX.GraphName} ) end test "creating an unnamed dataset with a list of initial statements" do ds = Dataset.new([ {EX.Subject1, EX.predicate1(), EX.Object1}, {EX.Subject2, EX.predicate2(), EX.Object2, EX.GraphName}, {EX.Subject3, EX.predicate3(), EX.Object3, nil} ]) assert unnamed_dataset?(ds) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1, nil}) assert dataset_includes_statement?( ds, {EX.Subject2, EX.predicate2(), EX.Object2, EX.GraphName} ) assert dataset_includes_statement?(ds, {EX.Subject3, EX.predicate3(), EX.Object3, nil}) end test "creating a named dataset with a list of initial statements" do ds = Dataset.new( [ {EX.Subject, EX.predicate1(), EX.Object1}, {EX.Subject, EX.predicate2(), EX.Object2, EX.GraphName}, {EX.Subject, EX.predicate3(), EX.Object3, nil} ], name: EX.DatasetName ) assert named_dataset?(ds, iri(EX.DatasetName)) assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate1(), EX.Object1, nil}) assert dataset_includes_statement?( ds, {EX.Subject, EX.predicate2(), EX.Object2, EX.GraphName} ) assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate3(), EX.Object3, nil}) end test "creating a named dataset with an initial description" do ds = Description.new(EX.Subject, init: {EX.predicate(), EX.Object}) |> Dataset.new(name: EX.DatasetName) assert named_dataset?(ds, iri(EX.DatasetName)) assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate(), EX.Object}) end test "creating an unnamed dataset with an initial description" do ds = Description.new(EX.Subject, init: {EX.predicate(), EX.Object}) |> Dataset.new() assert unnamed_dataset?(ds) assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate(), EX.Object}) end test "creating a named dataset with an initial graph" do ds = Dataset.new(Graph.new({EX.Subject, EX.predicate(), EX.Object}), name: EX.DatasetName) assert named_dataset?(ds, iri(EX.DatasetName)) assert unnamed_graph?(Dataset.default_graph(ds)) assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate(), EX.Object}) ds = Dataset.new(Graph.new({EX.Subject, EX.predicate(), EX.Object}, name: EX.GraphName), name: EX.DatasetName ) assert named_dataset?(ds, iri(EX.DatasetName)) assert unnamed_graph?(Dataset.default_graph(ds)) assert named_graph?(Dataset.graph(ds, EX.GraphName), iri(EX.GraphName)) assert dataset_includes_statement?( ds, {EX.Subject, EX.predicate(), EX.Object, EX.GraphName} ) end test "creating an unnamed dataset with an initial graph" do ds = Dataset.new(Graph.new({EX.Subject, EX.predicate(), EX.Object})) assert unnamed_dataset?(ds) assert unnamed_graph?(Dataset.default_graph(ds)) assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate(), EX.Object}) ds = Dataset.new(Graph.new({EX.Subject, EX.predicate(), EX.Object}, name: EX.GraphName)) assert unnamed_dataset?(ds) assert unnamed_graph?(Dataset.default_graph(ds)) assert named_graph?(Dataset.graph(ds, EX.GraphName), iri(EX.GraphName)) assert dataset_includes_statement?( ds, {EX.Subject, EX.predicate(), EX.Object, EX.GraphName} ) end test "with a context" do ds = Dataset.new({EX.S, :p, EX.O}, context: [p: EX.p()]) assert dataset_includes_statement?(ds, {EX.S, EX.p(), EX.O}) end @tag skip: "This case is currently not supported, since it's indistinguishable from Keywords" test "creating a dataset with a list of subject-predications pairs" do ds = Dataset.new([ {EX.S1, [ {EX.P1, EX.O1}, %{EX.P2 => [EX.O2]} ]} ]) assert dataset_includes_statement?(ds, {EX.S1, EX.P1, EX.O1}) assert dataset_includes_statement?(ds, {EX.S1, EX.P2, EX.O2}) end test "with init data" do ds = Dataset.new( init: [ {EX.S1, [ {EX.P1, EX.O1}, %{EX.P2 => [EX.O2]} ]} ] ) assert unnamed_dataset?(ds) assert dataset_includes_statement?(ds, {EX.S1, EX.P1, EX.O1}) assert dataset_includes_statement?(ds, {EX.S1, EX.P2, EX.O2}) ds = Dataset.new( name: EX.Dataset, init: {EX.S, EX.p(), EX.O} ) assert named_dataset?(ds, RDF.iri(EX.Dataset)) assert dataset_includes_statement?(ds, {EX.S, EX.p(), EX.O}) end test "with an initializer function" do ds = Dataset.new(init: fn -> {EX.S, EX.p(), EX.O} end) assert unnamed_dataset?(ds) assert dataset_includes_statement?(ds, {EX.S, EX.p(), EX.O}) end end test "name/1" do assert Dataset.name(dataset()) == dataset().name end test "change_name/2" do assert Dataset.change_name(dataset(), EX.NewDataset).name == iri(EX.NewDataset) assert Dataset.change_name(named_dataset(), nil).name == nil end describe "add/3" do test "a proper triple is added to the default graph" do assert Dataset.add(dataset(), {iri(EX.Subject), EX.predicate(), iri(EX.Object)}) |> dataset_includes_statement?({EX.Subject, EX.predicate(), EX.Object}) end test "a proper quad is added to the specified graph" do ds = Dataset.add(dataset(), {iri(EX.Subject), EX.predicate(), iri(EX.Object), iri(EX.Graph)}) assert dataset_includes_statement?( ds, {EX.Subject, EX.predicate(), EX.Object, iri(EX.Graph)} ) end test "a proper quad with nil context is added to the default graph" do ds = Dataset.add(dataset(), {iri(EX.Subject), EX.predicate(), iri(EX.Object), nil}) assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate(), EX.Object}) end test "a coercible triple" do assert Dataset.add( dataset(), {"http://example.com/Subject", EX.predicate(), EX.Object} ) |> dataset_includes_statement?({EX.Subject, EX.predicate(), EX.Object}) end test "a coercible quad" do assert Dataset.add( dataset(), {"http://example.com/Subject", EX.predicate(), EX.Object, "http://example.com/GraphName"} ) |> dataset_includes_statement?({EX.Subject, EX.predicate(), EX.Object, EX.GraphName}) end test "a quad and an overwriting graph context" do assert Dataset.add(dataset(), {EX.Subject, EX.predicate(), EX.Object, EX.Graph}, graph: EX.Other ) |> dataset_includes_statement?({EX.Subject, EX.predicate(), EX.Object, EX.Other}) assert Dataset.add(dataset(), {EX.Subject, EX.predicate(), EX.Object, EX.Graph}, graph: nil) |> dataset_includes_statement?({EX.Subject, EX.predicate(), EX.Object}) end test "statements with multiple objects" do ds = Dataset.add(dataset(), {EX.Subject1, EX.predicate1(), [EX.Object1, EX.Object2]}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object2}) ds = Dataset.add( dataset(), {EX.Subject1, EX.predicate1(), [EX.Object1, EX.Object2], EX.GraphName} ) assert dataset_includes_statement?( ds, {EX.Subject1, EX.predicate1(), EX.Object1, EX.GraphName} ) assert dataset_includes_statement?( ds, {EX.Subject1, EX.predicate1(), EX.Object2, EX.GraphName} ) end test "a list of triples without an overwriting graph context" do ds = Dataset.add(dataset(), [ {EX.Subject1, EX.predicate1(), EX.Object1}, {EX.Subject1, EX.predicate2(), EX.Object2}, {EX.Subject3, EX.predicate3(), EX.Object3} ]) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object2}) assert dataset_includes_statement?(ds, {EX.Subject3, EX.predicate3(), EX.Object3}) end test "a list of triples with an overwriting graph context" do ds = Dataset.add( dataset(), [ {EX.Subject1, EX.predicate1(), EX.Object1}, {EX.Subject1, EX.predicate2(), EX.Object2}, {EX.Subject3, EX.predicate3(), EX.Object3} ], graph: EX.Graph ) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1, EX.Graph}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object2, EX.Graph}) assert dataset_includes_statement?(ds, {EX.Subject3, EX.predicate3(), EX.Object3, EX.Graph}) ds = Dataset.add( dataset(), [ {EX.Subject1, EX.predicate1(), EX.Object1}, {EX.Subject1, EX.predicate2(), EX.Object2}, {EX.Subject3, EX.predicate3(), EX.Object3} ], graph: nil ) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1, nil}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object2, nil}) assert dataset_includes_statement?(ds, {EX.Subject3, EX.predicate3(), EX.Object3, nil}) end test "a list of quads without an overwriting graph context" do ds = Dataset.add(dataset(), [ {EX.Subject, EX.predicate1(), EX.Object1, EX.Graph1}, {EX.Subject, EX.predicate2(), EX.Object2, nil}, {EX.Subject, EX.predicate1(), EX.Object1, EX.Graph2} ]) assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate1(), EX.Object1, EX.Graph1}) assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate2(), EX.Object2, nil}) assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate1(), EX.Object1, EX.Graph2}) end test "a list of quads with an overwriting graph context" do ds = Dataset.add( dataset(), [ {EX.Subject, EX.predicate1(), EX.Object1, EX.Graph1}, {EX.Subject, EX.predicate2(), EX.Object2, nil}, {EX.Subject, EX.predicate1(), EX.Object1, EX.Graph2} ], graph: EX.Graph ) assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate1(), EX.Object1, EX.Graph}) assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate2(), EX.Object2, EX.Graph}) assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate1(), EX.Object1, EX.Graph}) ds = Dataset.add( dataset(), [ {EX.Subject, EX.predicate1(), EX.Object1, EX.Graph1}, {EX.Subject, EX.predicate2(), EX.Object2, nil}, {EX.Subject, EX.predicate1(), EX.Object1, EX.Graph2} ], graph: nil ) assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate1(), EX.Object1, nil}) assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate2(), EX.Object2, nil}) assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate1(), EX.Object1, nil}) end test "a list of mixed triples and quads" do ds = Dataset.add(dataset(), [ {EX.S1, EX.p1(), EX.O1, EX.Graph}, {EX.S3, EX.p3(), EX.O3} ]) assert dataset_includes_statement?(ds, {EX.S1, EX.p1(), EX.O1, EX.Graph}) assert dataset_includes_statement?(ds, {EX.S3, EX.p3(), EX.O3, nil}) ds = Dataset.add( dataset(), [ {EX.S1, EX.p1(), EX.O1, EX.Graph}, {EX.S3, EX.p3(), EX.O3} ], graph: EX.Graph2 ) assert dataset_includes_statement?(ds, {EX.S1, EX.p1(), EX.O1, EX.Graph2}) assert dataset_includes_statement?(ds, {EX.S3, EX.p3(), EX.O3, EX.Graph2}) end test "a map without an overwriting graph context" do ds = Dataset.add(dataset(), %{ EX.Subject1 => %{ EX.predicate1() => EX.Object1, EX.predicate2() => EX.Object2 }, EX.Subject3 => {EX.predicate3(), EX.Object3} }) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object2}) assert dataset_includes_statement?(ds, {EX.Subject3, EX.predicate3(), EX.Object3}) end test "a map with an overwriting graph context" do ds = Dataset.add( dataset(), %{ EX.Subject1 => [ {EX.predicate2(), EX.Object2}, {EX.predicate1(), EX.Object1} ], EX.Subject3 => %{EX.predicate3() => EX.Object3} }, graph: EX.Graph ) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1, EX.Graph}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object2, EX.Graph}) assert dataset_includes_statement?(ds, {EX.Subject3, EX.predicate3(), EX.Object3, EX.Graph}) ds = Dataset.add( dataset(), [ {EX.Subject1, EX.predicate1(), EX.Object1}, {EX.Subject1, EX.predicate2(), EX.Object2}, {EX.Subject3, EX.predicate3(), EX.Object3} ], graph: nil ) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1, nil}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object2, nil}) assert dataset_includes_statement?(ds, {EX.Subject3, EX.predicate3(), EX.Object3, nil}) end test "a description without an overwriting graph context" do ds = Dataset.add( dataset(), Description.new(EX.Subject1) |> Description.add([ {EX.predicate1(), EX.Object1}, {EX.predicate2(), EX.Object2} ]) ) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object2}) end test "a description with an overwriting graph context" do ds = Dataset.add( dataset(), Description.new(EX.Subject1, init: [ {EX.predicate1(), EX.Object1}, {EX.predicate2(), EX.Object2} ] ), graph: nil ) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object2}) ds = Dataset.add( ds, Description.new(EX.Subject1, init: {EX.predicate3(), EX.Object3}), graph: EX.Graph ) assert Enum.count(ds) == 3 assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object2}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate3(), EX.Object3, EX.Graph}) end test "an unnamed graph without an overwriting graph context" do ds = Dataset.add( dataset(), Graph.new([ {EX.Subject1, EX.predicate1(), EX.Object1}, {EX.Subject1, EX.predicate2(), EX.Object2} ]) ) assert unnamed_graph?(Dataset.default_graph(ds)) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object2}) ds = Dataset.add(ds, Graph.new({EX.Subject1, EX.predicate2(), EX.Object3})) assert unnamed_graph?(Dataset.default_graph(ds)) assert Enum.count(ds) == 3 assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object2}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object3}) end test "an unnamed graph with an overwriting graph context" do ds = Dataset.add( dataset(), Graph.new([ {EX.Subject1, EX.predicate1(), EX.Object1}, {EX.Subject1, EX.predicate2(), EX.Object2} ]), graph: nil ) assert unnamed_graph?(Dataset.default_graph(ds)) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object2}) ds = Dataset.add(ds, Graph.new({EX.Subject1, EX.predicate2(), EX.Object3}), graph: nil) assert unnamed_graph?(Dataset.default_graph(ds)) assert Enum.count(ds) == 3 assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object2}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object3}) ds = Dataset.add(ds, Graph.new({EX.Subject1, EX.predicate2(), EX.Object3}), graph: EX.Graph) assert unnamed_graph?(Dataset.default_graph(ds)) assert named_graph?(Dataset.graph(ds, EX.Graph), iri(EX.Graph)) assert Enum.count(ds) == 4 assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object2}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object3}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object3, EX.Graph}) end test "a named graph without an overwriting graph context" do ds = Dataset.add( dataset(), Graph.new( [ {EX.Subject1, EX.predicate1(), EX.Object1}, {EX.Subject1, EX.predicate2(), EX.Object2} ], name: EX.Graph1 ) ) assert Dataset.graph(ds, EX.Graph1) assert named_graph?(Dataset.graph(ds, EX.Graph1), iri(EX.Graph1)) assert unnamed_graph?(Dataset.default_graph(ds)) assert dataset_includes_statement?( ds, {EX.Subject1, EX.predicate1(), EX.Object1, EX.Graph1} ) assert dataset_includes_statement?( ds, {EX.Subject1, EX.predicate2(), EX.Object2, EX.Graph1} ) ds = Dataset.add(ds, Graph.new({EX.Subject1, EX.predicate2(), EX.Object3}, name: EX.Graph2)) assert Dataset.graph(ds, EX.Graph2) assert named_graph?(Dataset.graph(ds, EX.Graph2), iri(EX.Graph2)) assert unnamed_graph?(Dataset.default_graph(ds)) assert Enum.count(ds) == 3 assert dataset_includes_statement?( ds, {EX.Subject1, EX.predicate1(), EX.Object1, EX.Graph1} ) assert dataset_includes_statement?( ds, {EX.Subject1, EX.predicate2(), EX.Object2, EX.Graph1} ) assert dataset_includes_statement?( ds, {EX.Subject1, EX.predicate2(), EX.Object3, EX.Graph2} ) end test "a named graph with an overwriting graph context" do ds = Dataset.add( dataset(), Graph.new( [ {EX.Subject1, EX.predicate1(), EX.Object1}, {EX.Subject1, EX.predicate2(), EX.Object2} ], name: EX.Graph1 ), graph: nil ) refute Dataset.graph(ds, EX.Graph1) assert unnamed_graph?(Dataset.default_graph(ds)) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object2}) ds = Dataset.add( ds, Graph.new({EX.Subject1, EX.predicate2(), EX.Object3}, name: EX.Graph2), graph: nil ) refute Dataset.graph(ds, EX.Graph2) assert unnamed_graph?(Dataset.default_graph(ds)) assert Enum.count(ds) == 3 assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object2}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object3}) ds = Dataset.add( ds, Graph.new({EX.Subject1, EX.predicate2(), EX.Object3}, name: EX.Graph3), graph: EX.Graph ) assert named_graph?(Dataset.graph(ds, EX.Graph), iri(EX.Graph)) assert Enum.count(ds) == 4 assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object2}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object3}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object3, EX.Graph}) end test "an unnamed dataset" do ds = Dataset.add( dataset(), Dataset.new([ {EX.Subject1, EX.predicate1(), EX.Object1}, {EX.Subject1, EX.predicate2(), EX.Object2} ]) ) assert ds.name == nil assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object2}) ds = Dataset.add(ds, Dataset.new({EX.Subject1, EX.predicate2(), EX.Object3})) ds = Dataset.add(ds, Dataset.new({EX.Subject1, EX.predicate2(), EX.Object3, EX.Graph})) ds = Dataset.add(ds, Dataset.new({EX.Subject1, EX.predicate2(), EX.Object4}), graph: EX.Graph) assert ds.name == nil assert Enum.count(ds) == 5 assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object2}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object3}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object3, EX.Graph}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object4, EX.Graph}) end test "a named dataset" do ds = Dataset.add( named_dataset(), Dataset.new( [ {EX.Subject1, EX.predicate1(), EX.Object1}, {EX.Subject1, EX.predicate2(), EX.Object2} ], name: EX.DS1 ) ) assert ds.name == iri(EX.DatasetName) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object2}) ds = Dataset.add(ds, Dataset.new({EX.Subject1, EX.predicate2(), EX.Object3}, name: EX.DS2)) ds = Dataset.add( ds, Dataset.new({EX.Subject1, EX.predicate2(), EX.Object3, EX.Graph}, name: EX.DS2) ) ds = Dataset.add( ds, Dataset.new({EX.Subject1, EX.predicate2(), EX.Object4}, name: EX.DS2), graph: EX.Graph ) assert ds.name == iri(EX.DatasetName) assert Enum.count(ds) == 5 assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object2}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object3}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object3, EX.Graph}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2(), EX.Object4, EX.Graph}) end test "a list of descriptions" do ds = Dataset.add(dataset(), [ Description.new(EX.Subject1, init: {EX.predicate1(), EX.Object1}), Description.new(EX.Subject2, init: {EX.predicate2(), EX.Object2}), Description.new(EX.Subject1, init: {EX.predicate3(), EX.Object3}) ]) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1}) assert dataset_includes_statement?(ds, {EX.Subject2, EX.predicate2(), EX.Object2}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate3(), EX.Object3}) ds = Dataset.add( ds, [ Description.new(EX.Subject1, init: {EX.predicate1(), EX.Object1}), Description.new(EX.Subject2, init: {EX.predicate2(), EX.Object2}), Description.new(EX.Subject1, init: {EX.predicate3(), EX.Object3}) ], graph: EX.Graph ) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1, EX.Graph}) assert dataset_includes_statement?(ds, {EX.Subject2, EX.predicate2(), EX.Object2, EX.Graph}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate3(), EX.Object3, EX.Graph}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1(), EX.Object1}) assert dataset_includes_statement?(ds, {EX.Subject2, EX.predicate2(), EX.Object2}) assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate3(), EX.Object3}) end test "a list of graphs" do ds = Dataset.new([{EX.S1, EX.P1, EX.O1}, {EX.S2, EX.P2, EX.O2}]) |> Dataset.add([ Graph.new([{EX.S1, EX.P1, EX.O1}, {EX.S1, EX.P2, bnode(:foo)}]), Graph.new({EX.S1, EX.P2, EX.O3}), Graph.new([{EX.S1, EX.P2, EX.O2}, {EX.S2, EX.P2, EX.O2}], name: EX.Graph) ]) assert Enum.count(ds) == 6 assert dataset_includes_statement?(ds, {EX.S1, EX.P1, EX.O1}) assert dataset_includes_statement?(ds, {EX.S1, EX.P2, bnode(:foo)}) assert dataset_includes_statement?(ds, {EX.S1, EX.P2, EX.O3}) assert dataset_includes_statement?(ds, {EX.S2, EX.P2, EX.O2}) assert dataset_includes_statement?(ds, {EX.S1, EX.P2, EX.O2, EX.Graph}) assert dataset_includes_statement?(ds, {EX.S2, EX.P2, EX.O2, EX.Graph}) end test "lists of descriptions, graphs and datasets without an overwriting graph context" do ds = Dataset.new([{EX.S1, EX.p(), EX.O}, {EX.S2, EX.p(), EX.O, EX.Graph}]) |> Dataset.add([ EX.S1 |> EX.p(bnode(:foo)), %{EX.S1 => {EX.p(), EX.O1}}, EX.S2 |> EX.p(EX.O3) |> RDF.graph(), EX.S2 |> EX.p(EX.O4) |> RDF.graph(name: EX.Graph), EX.S2 |> EX.p(EX.O5) |> RDF.dataset() ]) assert Dataset.statement_count(ds) == 7 assert dataset_includes_statement?(ds, {EX.S1, EX.p(), EX.O}) assert dataset_includes_statement?(ds, {EX.S1, EX.p(), bnode(:foo)}) assert dataset_includes_statement?(ds, {EX.S1, EX.p(), EX.O1}) assert dataset_includes_statement?(ds, {EX.S2, EX.p(), EX.O3}) assert dataset_includes_statement?(ds, {EX.S2, EX.p(), EX.O5}) assert dataset_includes_statement?(ds, {EX.S2, EX.p(), EX.O, EX.Graph}) assert dataset_includes_statement?(ds, {EX.S2, EX.p(), EX.O4, EX.Graph}) end test "lists of descriptions, graphs and datasets with an overwriting graph context" do ds = Dataset.new([{EX.S1, EX.p(), EX.O}, {EX.S2, EX.p(), EX.O, EX.Graph}]) |> Dataset.add( [ EX.S1 |> EX.p(bnode(:foo)), %{EX.S1 => {EX.p(), EX.O1}}, EX.S2 |> EX.p(EX.O3) |> RDF.graph(), EX.S2 |> EX.p(EX.O4) |> RDF.graph(name: EX.Graph), EX.S2 |> EX.p(EX.O5) |> RDF.dataset() ], graph: EX.Graph2 ) assert Dataset.statement_count(ds) == 7 assert dataset_includes_statement?(ds, {EX.S1, EX.p(), EX.O}) assert dataset_includes_statement?(ds, {EX.S2, EX.p(), EX.O, EX.Graph}) assert dataset_includes_statement?(ds, {EX.S1, EX.p(), bnode(:foo), EX.Graph2}) assert dataset_includes_statement?(ds, {EX.S1, EX.p(), EX.O1, EX.Graph2}) assert dataset_includes_statement?(ds, {EX.S2, EX.p(), EX.O3, EX.Graph2}) assert dataset_includes_statement?(ds, {EX.S2, EX.p(), EX.O4, EX.Graph2}) assert dataset_includes_statement?(ds, {EX.S2, EX.p(), EX.O5, EX.Graph2}) end test "with a context" do context = PropertyMap.new( p1: EX.p1(), p2: EX.p2() ) assert Dataset.add(dataset(), {EX.Subject, :p, 42}, context: [p: EX.predicate()]) |> dataset_includes_statement?({RDF.iri(EX.Subject), EX.predicate(), literal(42)}) assert Dataset.add(dataset(), {EX.Subject, :p, 42, EX.Graph}, context: %{p: EX.predicate()}) |> dataset_includes_statement?( {RDF.iri(EX.Subject), EX.predicate(), literal(42), EX.Graph} ) g = Dataset.add( dataset(), [ {EX.S1, :p1, EX.O1}, {EX.S2, :p2, [EX.O21, EX.O22]} ], context: context ) assert Dataset.statement_count(g) == 3 assert dataset_includes_statement?(g, {EX.S1, EX.p1(), EX.O1}) assert dataset_includes_statement?(g, {EX.S2, EX.p2(), EX.O21}) assert dataset_includes_statement?(g, {EX.S2, EX.p2(), EX.O22}) g = Dataset.add( dataset(), [ {EX.S1, [ {:p1, EX.O1}, %{p2: [EX.O2]} ]} ], context: context ) assert Dataset.statement_count(g) == 2 assert dataset_includes_statement?(g, {EX.S1, EX.p1(), EX.O1}) assert dataset_includes_statement?(g, {EX.S1, EX.p2(), EX.O2}) end test "duplicates are ignored" do ds = Dataset.add(dataset(), {EX.Subject, EX.predicate(), EX.Object, EX.GraphName}) assert Dataset.add(ds, {EX.Subject, EX.predicate(), EX.Object, EX.GraphName}) == ds end test "non-coercible statements elements are causing an error" do assert_raise RDF.IRI.InvalidError, fn -> Dataset.add(dataset(), {"not a IRI", EX.predicate(), iri(EX.Object), iri(EX.GraphName)}) end assert_raise RDF.Literal.InvalidError, fn -> Dataset.add(dataset(), {EX.Subject, EX.prop(), self(), nil}) end assert_raise RDF.IRI.InvalidError, fn -> Dataset.add(dataset(), {iri(EX.Subject), EX.predicate(), iri(EX.Object), "not a IRI"}) end assert_raise RDF.IRI.InvalidError, fn -> Dataset.add(dataset(), {iri(EX.Subject), EX.predicate(), iri(EX.Object)}, graph: "not a IRI" ) end end test "structs are causing an error" do assert_raise FunctionClauseError, fn -> Dataset.add(dataset(), Date.utc_today()) end end end describe "put/3" do test "a list of statements without an overwriting graph context" do ds = Dataset.new([ {EX.S1, EX.P1, EX.O1}, {EX.S2, EX.P2, EX.O2, EX.Graph}, {EX.S3, EX.P3, EX.O3, EX.Graph} ]) |> Dataset.put([ {EX.S1, EX.P2, bnode(:foo), nil}, {EX.S1, EX.P2, EX.O3, EX.Graph}, {EX.S2, EX.P3, EX.O3, EX.Graph}, {EX.S3, EX.P3, EX.O3} ]) assert Dataset.statement_count(ds) == 5 assert dataset_includes_statement?(ds, {EX.S1, EX.P2, bnode(:foo)}) assert dataset_includes_statement?(ds, {EX.S1, EX.P2, EX.O3, EX.Graph}) assert dataset_includes_statement?(ds, {EX.S2, EX.P3, EX.O3, EX.Graph}) assert dataset_includes_statement?(ds, {EX.S3, EX.P3, EX.O3}) assert dataset_includes_statement?(ds, {EX.S3, EX.P3, EX.O3, EX.Graph}) end test "a list of statements with an overwriting graph context" do ds = Dataset.new([ {EX.S1, EX.P1, EX.O1}, {EX.S2, EX.P2, EX.O2}, {EX.S3, EX.P3, EX.O3, EX.Graph} ]) |> Dataset.put( [ {EX.S1, EX.P2, bnode(:foo), nil}, {EX.S1, EX.P2, EX.O3, EX.Graph}, {EX.S1, EX.P3, EX.O3}, {EX.S2, EX.P3, EX.O3}, {EX.S3, EX.P4, EX.O4, EX.Graph} ], graph: nil ) assert Dataset.statement_count(ds) == 6 assert dataset_includes_statement?(ds, {EX.S1, EX.P2, bnode(:foo)}) assert dataset_includes_statement?(ds, {EX.S1, EX.P2, EX.O3}) assert dataset_includes_statement?(ds, {EX.S1, EX.P3, EX.O3}) assert dataset_includes_statement?(ds, {EX.S2, EX.P3, EX.O3}) assert dataset_includes_statement?(ds, {EX.S3, EX.P4, EX.O4}) assert dataset_includes_statement?(ds, {EX.S3, EX.P3, EX.O3, EX.Graph}) ds = Dataset.new([ {EX.S1, EX.P1, EX.O1}, {EX.S2, EX.P2, EX.O2}, {EX.S3, EX.P3, EX.O3, EX.Graph} ]) |> Dataset.put( [ {EX.S1, EX.P2, bnode(:foo), nil}, {EX.S1, EX.P2, EX.O3, EX.Graph}, {EX.S1, EX.P3, EX.O3}, {EX.S2, EX.P3, EX.O3}, {EX.S3, EX.P4, EX.O4, EX.Graph} ], graph: EX.Graph2 ) assert Dataset.statement_count(ds) == 8 assert dataset_includes_statement?(ds, {EX.S1, EX.P1, EX.O1}) assert dataset_includes_statement?(ds, {EX.S2, EX.P2, EX.O2}) assert dataset_includes_statement?(ds, {EX.S1, EX.P2, bnode(:foo), EX.Graph2}) assert dataset_includes_statement?(ds, {EX.S1, EX.P2, EX.O3, EX.Graph2}) assert dataset_includes_statement?(ds, {EX.S1, EX.P3, EX.O3, EX.Graph2}) assert dataset_includes_statement?(ds, {EX.S2, EX.P3, EX.O3, EX.Graph2}) assert dataset_includes_statement?(ds, {EX.S3, EX.P4, EX.O4, EX.Graph2}) assert dataset_includes_statement?(ds, {EX.S3, EX.P3, EX.O3, EX.Graph}) end test "lists of subject-predications pairs" do ds = Dataset.new([{EX.S1, EX.p1(), EX.O1}, {EX.S2, EX.p2(), EX.O2}]) |> Dataset.put([ {EX.S1, [{EX.p2(), EX.O2}]}, {EX.S3, %{EX.p3() => EX.O3}} ]) assert Dataset.statement_count(ds) == 3 assert dataset_includes_statement?(ds, {EX.S1, EX.p2(), EX.O2}) assert dataset_includes_statement?(ds, {EX.S2, EX.p2(), EX.O2}) assert dataset_includes_statement?(ds, {EX.S3, EX.p3(), EX.O3}) end test "maps" do ds = Dataset.new([{EX.S1, EX.p1(), EX.O1}, {EX.S2, EX.p2(), EX.O2}]) |> Dataset.put(%{ EX.S1 => [{EX.p2(), EX.O2}], EX.S2 => %{EX.p1() => EX.O2}, EX.S3 => %{EX.p3() => EX.O3} }) assert Dataset.statement_count(ds) == 3 assert dataset_includes_statement?(ds, {EX.S1, EX.p2(), EX.O2}) assert dataset_includes_statement?(ds, {EX.S2, EX.p1(), EX.O2}) assert dataset_includes_statement?(ds, {EX.S3, EX.p3(), EX.O3}) end test "descriptions" do ds = Dataset.new([ {EX.S1, EX.P1, EX.O1}, {EX.S1, EX.P3, EX.O3}, {EX.S2, EX.P2, EX.O2} ]) |> Dataset.put( Description.new(EX.S1) |> Description.add([{EX.P3, EX.O4}, {EX.P2, bnode(:foo)}]) ) assert Dataset.statement_count(ds) == 3 assert dataset_includes_statement?(ds, {EX.S1, EX.P3, EX.O4}) assert dataset_includes_statement?(ds, {EX.S1, EX.P2, bnode(:foo)}) assert dataset_includes_statement?(ds, {EX.S2, EX.P2, EX.O2}) end test "an unnamed graph without an overwriting graph context" do ds = Dataset.new([ {EX.S1, EX.P1, EX.O1}, {EX.S1, EX.P2, EX.O2}, {EX.S2, EX.P2, EX.O2} ]) |> Dataset.put( Graph.new([ {EX.S1, EX.P3, EX.O4}, {EX.S1, EX.P2, bnode(:foo)} ]) ) assert Dataset.statement_count(ds) == 3 assert dataset_includes_statement?(ds, {EX.S1, EX.P3, EX.O4}) assert dataset_includes_statement?(ds, {EX.S1, EX.P2, bnode(:foo)}) assert dataset_includes_statement?(ds, {EX.S2, EX.P2, EX.O2}) end test "an unnamed graph with an overwriting graph context" do ds = Dataset.new([ {EX.S1, EX.P1, EX.O1}, {EX.S1, EX.P2, EX.O2}, {EX.S2, EX.P2, EX.O2} ]) |> Dataset.put( Graph.new([ {EX.S1, EX.P3, EX.O3}, {EX.S2, EX.P2, bnode(:foo)} ]), graph: nil ) assert Dataset.statement_count(ds) == 2 assert dataset_includes_statement?(ds, {EX.S1, EX.P3, EX.O3}) assert dataset_includes_statement?(ds, {EX.S2, EX.P2, bnode(:foo)}) ds = Dataset.new([ {EX.S1, EX.P1, EX.O1}, {EX.S2, EX.P2, EX.O2, EX.Graph} ]) |> Dataset.put( Graph.new([ {EX.S1, EX.P3, EX.O3}, {EX.S2, EX.P2, bnode(:foo)} ]), graph: EX.Graph ) assert Dataset.statement_count(ds) == 3 assert dataset_includes_statement?(ds, {EX.S1, EX.P1, EX.O1}) assert dataset_includes_statement?(ds, {EX.S1, EX.P3, EX.O3, EX.Graph}) assert dataset_includes_statement?(ds, {EX.S2, EX.P2, bnode(:foo), EX.Graph}) end test "a named graph without an overwriting graph context" do ds = Dataset.new([ {EX.S1, EX.P1, EX.O1}, {EX.S1, EX.P2, EX.O2, EX.Graph}, {EX.S2, EX.P2, EX.O2, EX.Graph} ]) |> Dataset.put( Graph.new( [ {EX.S1, EX.P3, EX.O4}, {EX.S1, EX.P2, bnode(:foo)} ], name: EX.Graph ) ) assert Dataset.statement_count(ds) == 4 assert dataset_includes_statement?(ds, {EX.S1, EX.P1, EX.O1}) assert dataset_includes_statement?(ds, {EX.S1, EX.P3, EX.O4, EX.Graph}) assert dataset_includes_statement?(ds, {EX.S1, EX.P2, bnode(:foo), EX.Graph}) assert dataset_includes_statement?(ds, {EX.S2, EX.P2, EX.O2, EX.Graph}) end test "a named graph with an overwriting graph context" do ds = Dataset.new([ {EX.S1, EX.P1, EX.O1}, {EX.S1, EX.P2, EX.O2, EX.Graph}, {EX.S2, EX.P2, EX.O2} ]) |> Dataset.put( Graph.new( [ {EX.S1, EX.P3, EX.O3}, {EX.S2, EX.P3, bnode(:foo)} ], name: EX.Graph ), graph: nil ) assert Dataset.statement_count(ds) == 3 assert dataset_includes_statement?(ds, {EX.S1, EX.P2, EX.O2, EX.Graph}) assert dataset_includes_statement?(ds, {EX.S1, EX.P3, EX.O3}) assert dataset_includes_statement?(ds, {EX.S2, EX.P3, bnode(:foo)}) ds = Dataset.new([ {EX.S1, EX.P1, EX.O1}, {EX.S2, EX.P2, EX.O2, EX.Graph} ]) |> Dataset.put( Graph.new( [ {EX.S1, EX.P3, EX.O3}, {EX.S2, EX.P3, bnode(:foo)} ], name: EX.Graph2 ), graph: EX.Graph ) assert Dataset.statement_count(ds) == 3 assert dataset_includes_statement?(ds, {EX.S1, EX.P1, EX.O1}) assert dataset_includes_statement?(ds, {EX.S1, EX.P3, EX.O3, EX.Graph}) assert dataset_includes_statement?(ds, {EX.S2, EX.P3, bnode(:foo), EX.Graph}) end test "lists of descriptions, graphs and datasets" do ds = Dataset.new([{EX.S1, EX.p(), EX.O}, {EX.S2, EX.p(), EX.O, EX.Graph}]) |> Dataset.put([ EX.S1 |> EX.p2(bnode(:foo)), EX.S1 |> EX.p2("bar"), %{EX.S1 => {EX.p2(), EX.O1}}, EX.S2 |> EX.p2(EX.O3) |> RDF.graph(), EX.S2 |> EX.p2(EX.O4) |> RDF.graph(name: EX.Graph), EX.S2 |> EX.p2(EX.O5) |> RDF.dataset() ]) assert Dataset.statement_count(ds) == 6 assert dataset_includes_statement?(ds, {EX.S1, EX.p2(), bnode(:foo)}) assert dataset_includes_statement?(ds, {EX.S1, EX.p2(), ~L"bar"}) assert dataset_includes_statement?(ds, {EX.S1, EX.p2(), EX.O1}) assert dataset_includes_statement?(ds, {EX.S2, EX.p2(), EX.O3}) assert dataset_includes_statement?(ds, {EX.S2, EX.p2(), EX.O4, EX.Graph}) assert dataset_includes_statement?(ds, {EX.S2, EX.p2(), EX.O5}) end test "with a context" do ds = Dataset.new() |> Dataset.put({EX.S, :p, EX.O}, context: [p: EX.p()]) assert dataset_includes_statement?(ds, {EX.S, EX.p(), EX.O}) end test "simultaneous use of the different forms to address the default context" do ds = Dataset.put(dataset(), [ {EX.S, EX.P, EX.O1}, {EX.S, EX.P, EX.O2, nil} ]) assert Dataset.statement_count(ds) == 2 assert dataset_includes_statement?(ds, {EX.S, EX.P, EX.O1}) assert dataset_includes_statement?(ds, {EX.S, EX.P, EX.O2}) end test "structs are causing an error" do assert_raise FunctionClauseError, fn -> Dataset.put(dataset(), Date.utc_today()) end end end describe "put_properties/3" do test "a list of statements without an overwriting graph context" do ds = Dataset.new([{EX.S1, EX.P1, EX.O1}, {EX.S2, EX.P2, EX.O2, EX.Graph}]) |> Dataset.put_properties([ {EX.S1, EX.P2, EX.O3, EX.Graph}, {EX.S1, EX.P2, bnode(:foo), nil}, {EX.S2, EX.P2, EX.O3, EX.Graph}, {EX.S2, EX.P2, EX.O4, EX.Graph} ]) assert Dataset.statement_count(ds) == 5 assert dataset_includes_statement?(ds, {EX.S1, EX.P1, EX.O1}) assert dataset_includes_statement?(ds, {EX.S1, EX.P2, bnode(:foo)}) assert dataset_includes_statement?(ds, {EX.S1, EX.P2, EX.O3, EX.Graph}) assert dataset_includes_statement?(ds, {EX.S2, EX.P2, EX.O3, EX.Graph}) assert dataset_includes_statement?(ds, {EX.S2, EX.P2, EX.O4, EX.Graph}) end test "a list of statements with an overwriting graph context" do ds = Dataset.new([{EX.S1, EX.P1, EX.O1}, {EX.S2, EX.P2, EX.O2, EX.Graph}]) |> Dataset.put_properties( [ {EX.S1, EX.P1, EX.O3, EX.Graph}, {EX.S1, EX.P2, bnode(:foo), nil}, {EX.S2, EX.P2, EX.O3, EX.Graph}, {EX.S2, EX.P2, EX.O4} ], graph: nil ) assert Dataset.statement_count(ds) == 5 assert dataset_includes_statement?(ds, {EX.S1, EX.P1, EX.O3}) assert dataset_includes_statement?(ds, {EX.S1, EX.P2, bnode(:foo)}) assert dataset_includes_statement?(ds, {EX.S2, EX.P2, EX.O3}) assert dataset_includes_statement?(ds, {EX.S2, EX.P2, EX.O4}) assert dataset_includes_statement?(ds, {EX.S2, EX.P2, EX.O2, EX.Graph}) ds = Dataset.new([{EX.S1, EX.P1, EX.O1}, {EX.S2, EX.P2, EX.O2, EX.Graph}]) |> Dataset.put_properties( [ {EX.S1, EX.P1, EX.O3}, {EX.S1, EX.P1, EX.O4, EX.Graph}, {EX.S1, EX.P2, bnode(:foo), nil}, {EX.S2, EX.P2, EX.O3, EX.Graph}, {EX.S2, EX.P2, EX.O4} ], graph: EX.Graph ) assert Dataset.statement_count(ds) == 6 assert dataset_includes_statement?(ds, {EX.S1, EX.P1, EX.O1}) assert dataset_includes_statement?(ds, {EX.S1, EX.P1, EX.O3, EX.Graph}) assert dataset_includes_statement?(ds, {EX.S1, EX.P1, EX.O4, EX.Graph}) assert dataset_includes_statement?(ds, {EX.S1, EX.P2, bnode(:foo), EX.Graph}) assert dataset_includes_statement?(ds, {EX.S2, EX.P2, EX.O3, EX.Graph}) assert dataset_includes_statement?(ds, {EX.S2, EX.P2, EX.O4, EX.Graph}) end test "lists of subject-predications pairs" do ds = Dataset.new([{EX.S1, EX.p1(), EX.O1}, {EX.S2, EX.p2(), EX.O2}]) |> Dataset.put_properties([ {EX.S1, [{EX.p1(), EX.O2}]}, {EX.S2, %{EX.p1() => EX.O2}}, {EX.S3, %{EX.p3() => EX.O3}} ]) assert Dataset.statement_count(ds) == 4 assert dataset_includes_statement?(ds, {EX.S1, EX.p1(), EX.O2}) assert dataset_includes_statement?(ds, {EX.S2, EX.p2(), EX.O2}) assert dataset_includes_statement?(ds, {EX.S2, EX.p1(), EX.O2}) assert dataset_includes_statement?(ds, {EX.S3, EX.p3(), EX.O3}) end test "maps" do ds = Dataset.new([{EX.S1, EX.p1(), EX.O1}, {EX.S2, EX.p2(), EX.O2}]) |> Dataset.put_properties(%{ EX.S1 => [{EX.p1(), EX.O2}], EX.S2 => %{EX.p1() => EX.O2}, EX.S3 => %{EX.p3() => EX.O3} }) assert Dataset.statement_count(ds) == 4 assert dataset_includes_statement?(ds, {EX.S1, EX.p1(), EX.O2}) assert dataset_includes_statement?(ds, {EX.S2, EX.p2(), EX.O2}) assert dataset_includes_statement?(ds, {EX.S2, EX.p1(), EX.O2}) assert dataset_includes_statement?(ds, {EX.S3, EX.p3(), EX.O3}) end test "descriptions" do ds = Dataset.new([{EX.S1, EX.P1, EX.O1}, {EX.S2, EX.P2, EX.O2}, {EX.S1, EX.P3, EX.O3}]) |> Dataset.put_properties( Description.new(EX.S1) |> Description.add([{EX.P3, EX.O4}, {EX.P2, bnode(:foo)}]) ) assert Dataset.statement_count(ds) == 4 assert dataset_includes_statement?(ds, {EX.S1, EX.P1, EX.O1}) assert dataset_includes_statement?(ds, {EX.S1, EX.P3, EX.O4}) assert dataset_includes_statement?(ds, {EX.S1, EX.P2, bnode(:foo)}) assert dataset_includes_statement?(ds, {EX.S2, EX.P2, EX.O2}) end test "an unnamed graph" do ds = Dataset.new([{EX.S1, EX.P1, EX.O1}, {EX.S2, EX.P2, EX.O2}, {EX.S1, EX.P3, EX.O3}]) |> Dataset.put_properties(Graph.new([{EX.S1, EX.P3, EX.O4}, {EX.S1, EX.P2, bnode(:foo)}])) assert Dataset.statement_count(ds) == 4 assert dataset_includes_statement?(ds, {EX.S1, EX.P1, EX.O1}) assert dataset_includes_statement?(ds, {EX.S1, EX.P3, EX.O4}) assert dataset_includes_statement?(ds, {EX.S1, EX.P2, bnode(:foo)}) assert dataset_includes_statement?(ds, {EX.S2, EX.P2, EX.O2}) end test "a named graph" do ds = Dataset.new( Graph.new([{EX.S1, EX.P1, EX.O1}, {EX.S2, EX.P2, EX.O2}, {EX.S1, EX.P3, EX.O3}], name: EX.GraphName ) ) |> Dataset.put_properties( Graph.new([{EX.S1, EX.P3, EX.O4}, {EX.S1, EX.P2, bnode(:foo)}]), graph: EX.GraphName ) assert Dataset.statement_count(ds) == 4 assert dataset_includes_statement?(ds, {EX.S1, EX.P1, EX.O1, EX.GraphName}) assert dataset_includes_statement?(ds, {EX.S1, EX.P3, EX.O4, EX.GraphName}) assert dataset_includes_statement?(ds, {EX.S1, EX.P2, bnode(:foo), EX.GraphName}) assert dataset_includes_statement?(ds, {EX.S2, EX.P2, EX.O2, EX.GraphName}) end test "lists of descriptions, graphs and datasets" do ds = Dataset.new([{EX.S1, EX.p(), EX.O}, {EX.S2, EX.p(), EX.O, EX.Graph}]) |> Dataset.put_properties([ EX.S1 |> EX.p(bnode(:foo)), EX.S1 |> EX.p("bar"), %{EX.S1 => {EX.p(), EX.O1}}, EX.S2 |> EX.p(EX.O3) |> RDF.graph(), EX.S2 |> EX.p(EX.O4) |> RDF.graph(name: EX.Graph), EX.S2 |> EX.p(EX.O5) |> RDF.dataset() ]) assert Dataset.statement_count(ds) == 6 assert dataset_includes_statement?(ds, {EX.S1, EX.p(), bnode(:foo)}) assert dataset_includes_statement?(ds, {EX.S1, EX.p(), ~L"bar"}) assert dataset_includes_statement?(ds, {EX.S1, EX.p(), EX.O1}) assert dataset_includes_statement?(ds, {EX.S2, EX.p(), EX.O3}) assert dataset_includes_statement?(ds, {EX.S2, EX.p(), EX.O4, EX.Graph}) assert dataset_includes_statement?(ds, {EX.S2, EX.p(), EX.O5}) end test "with a context" do ds = Dataset.new() |> Dataset.put_properties({EX.S, :p, EX.O}, context: [p: EX.p()]) assert dataset_includes_statement?(ds, {EX.S, EX.p(), EX.O}) end test "simultaneous use of the different forms to address the default context" do ds = Dataset.put_properties(dataset(), [ {EX.S, EX.P, EX.O1}, {EX.S, EX.P, EX.O2, nil} ]) assert Dataset.statement_count(ds) == 2 assert dataset_includes_statement?(ds, {EX.S, EX.P, EX.O1}) assert dataset_includes_statement?(ds, {EX.S, EX.P, EX.O2}) end test "structs are causing an error" do assert_raise FunctionClauseError, fn -> Dataset.put_properties(dataset(), Date.utc_today()) end end end describe "delete" do setup do {:ok, dataset1: Dataset.new({EX.S1, EX.p1(), EX.O1}), dataset2: Dataset.new([ {EX.S1, EX.p1(), EX.O1}, {EX.S2, EX.p2(), EX.O2, EX.Graph} ]), dataset3: Dataset.new([ {EX.S1, EX.p1(), EX.O1}, {EX.S2, EX.p2(), [EX.O1, EX.O2], EX.Graph1}, {EX.S3, EX.p3(), [~B, ~L"bar"], EX.Graph2} ])} end test "a single statement", %{dataset1: dataset1, dataset2: dataset2, dataset3: dataset3} do assert Dataset.delete(Dataset.new(), {EX.S, EX.p(), EX.O}) == Dataset.new() assert Dataset.delete(dataset1, {EX.S1, EX.p1(), EX.O1}) == Dataset.new() assert Dataset.delete(dataset2, {EX.S2, EX.p2(), EX.O2, EX.Graph}) == dataset1 assert Dataset.delete(dataset2, {EX.S1, EX.p1(), EX.O1}) == Dataset.new({EX.S2, EX.p2(), EX.O2, EX.Graph}) assert Dataset.delete(dataset3, {EX.S2, EX.p2(), EX.O1, EX.Graph1}) == Dataset.new([ {EX.S1, EX.p1(), EX.O1}, {EX.S2, EX.p2(), EX.O2, EX.Graph1}, {EX.S3, EX.p3(), [~B, ~L"bar"], EX.Graph2} ]) assert Dataset.delete(dataset3, {EX.S2, EX.p2(), [EX.O1, EX.O2], EX.Graph1}) == Dataset.new([ {EX.S1, EX.p1(), EX.O1}, {EX.S3, EX.p3(), [~B, ~L"bar"], EX.Graph2} ]) assert Dataset.delete(dataset3, {EX.S2, EX.p2(), [EX.O1, EX.O2]}, graph: EX.Graph1) == Dataset.new([ {EX.S1, EX.p1(), EX.O1}, {EX.S3, EX.p3(), [~B, ~L"bar"], EX.Graph2} ]) end test "multiple statements with a list of triples", %{dataset1: dataset1, dataset2: dataset2, dataset3: dataset3} do assert Dataset.delete(dataset1, [{EX.S1, EX.p1(), EX.O1}, {EX.S1, EX.p1(), EX.O2}]) == Dataset.new() assert Dataset.delete(dataset2, [{EX.S1, EX.p1(), EX.O1}, {EX.S2, EX.p2(), EX.O2, EX.Graph}]) == Dataset.new() assert Dataset.delete(dataset3, [ {EX.S1, EX.p1(), EX.O1}, {EX.S2, EX.p2(), [EX.O1, EX.O2, EX.O3], EX.Graph1}, {EX.S3, EX.p3(), ~B, EX.Graph2} ]) == Dataset.new({EX.S3, EX.p3(), ~L"bar", EX.Graph2}) end test "multiple statements with a map", %{dataset1: dataset1, dataset2: dataset2} do assert Dataset.delete(dataset1, %{EX.S1 => {EX.p1(), EX.O1}}) == Dataset.new() assert Dataset.delete( dataset1, %{EX.S1 => {EX.p1(), EX.O1}}, graph: EX.Graph ) == dataset1 assert Dataset.delete( dataset2, %{EX.S2 => %{EX.p2() => EX.O2}}, graph: EX.Graph ) == dataset1 assert Dataset.delete(dataset2, %{EX.S1 => %{EX.p1() => EX.O1}}) == Dataset.new({EX.S2, EX.p2(), EX.O2, EX.Graph}) end test "multiple statements with a description", %{dataset1: dataset1, dataset2: dataset2} do assert Dataset.delete(dataset1, Description.new(EX.S1, init: {EX.p1(), EX.O1})) == Dataset.new() assert Dataset.delete(dataset1, Description.new(EX.S1, init: {EX.p1(), EX.O1}), graph: EX.Graph ) == dataset1 assert Dataset.delete(dataset2, Description.new(EX.S2, init: {EX.p2(), EX.O2}), graph: EX.Graph ) == dataset1 assert Dataset.delete(dataset2, Description.new(EX.S1, init: {EX.p1(), EX.O1})) == Dataset.new({EX.S2, EX.p2(), EX.O2, EX.Graph}) end test "multiple statements with a graph", %{dataset1: dataset1, dataset2: dataset2, dataset3: dataset3} do assert Dataset.delete(dataset1, Graph.new({EX.S1, EX.p1(), EX.O1})) == Dataset.new() assert Dataset.delete(dataset2, Graph.new({EX.S1, EX.p1(), EX.O1})) == Dataset.new({EX.S2, EX.p2(), EX.O2, EX.Graph}) assert Dataset.delete(dataset2, Graph.new({EX.S2, EX.p2(), EX.O2}, name: EX.Graph)) == dataset1 assert Dataset.delete(dataset2, Graph.new({EX.S2, EX.p2(), EX.O2}, name: EX.Graph)) == dataset1 assert Dataset.delete(dataset2, Graph.new({EX.S2, EX.p2(), EX.O2}), graph: EX.Graph) == dataset1 assert Dataset.delete(dataset2, Graph.new({EX.S2, EX.p2(), EX.O2}), graph: EX.Graph) == dataset1 assert Dataset.delete( dataset3, Graph.new([ {EX.S1, EX.p1(), [EX.O1, EX.O2]}, {EX.S2, EX.p2(), EX.O3}, {EX.S3, EX.p3(), ~B} ]) ) == Dataset.new([ {EX.S2, EX.p2(), [EX.O1, EX.O2], EX.Graph1}, {EX.S3, EX.p3(), [~B, ~L"bar"], EX.Graph2} ]) assert Dataset.delete( dataset3, Graph.new( [ {EX.S1, EX.p1(), [EX.O1, EX.O2]}, {EX.S2, EX.p2(), EX.O3}, {EX.S3, EX.p3(), ~B} ], name: EX.Graph2 ) ) == Dataset.new([ {EX.S1, EX.p1(), EX.O1}, {EX.S2, EX.p2(), [EX.O1, EX.O2], EX.Graph1}, {EX.S3, EX.p3(), [~L"bar"], EX.Graph2} ]) assert Dataset.delete(dataset3, Graph.new({EX.S3, EX.p3(), ~B}), graph: EX.Graph2) == Dataset.new([ {EX.S1, EX.p1(), EX.O1}, {EX.S2, EX.p2(), [EX.O1, EX.O2], EX.Graph1}, {EX.S3, EX.p3(), ~L"bar", EX.Graph2} ]) end test "multiple statements with a dataset", %{dataset1: dataset1, dataset2: dataset2} do assert Dataset.delete(dataset1, dataset1) == Dataset.new() assert Dataset.delete(dataset1, dataset2) == Dataset.new() assert Dataset.delete(dataset2, dataset1) == Dataset.new({EX.S2, EX.p2(), EX.O2, EX.Graph}) end test "with a context", %{dataset2: dataset2} do assert dataset2 |> Dataset.delete(%{EX.S2 => %{p2: EX.O2}}, graph: EX.Graph, context: [p2: EX.p2()]) |> Dataset.delete([{EX.S1, [p1: EX.O1]}], context: [p1: EX.p1()]) == Dataset.new() end test "structs are causing an error" do assert_raise FunctionClauseError, fn -> Dataset.delete(dataset(), Date.utc_today()) end end end describe "delete_graph" do setup do {:ok, dataset1: Dataset.new({EX.S1, EX.p1(), EX.O1}), dataset2: Dataset.new([ {EX.S1, EX.p1(), EX.O1}, {EX.S2, EX.p2(), EX.O2, EX.Graph} ]), dataset3: Dataset.new([ {EX.S1, EX.p1(), EX.O1}, {EX.S2, EX.p2(), EX.O2, EX.Graph1}, {EX.S3, EX.p3(), EX.O3, EX.Graph2} ])} end test "the default graph", %{dataset1: dataset1, dataset2: dataset2} do assert Dataset.delete_graph(dataset1, nil) == Dataset.new() assert Dataset.delete_graph(dataset2, nil) == Dataset.new({EX.S2, EX.p2(), EX.O2, EX.Graph}) end test "delete_default_graph", %{dataset1: dataset1, dataset2: dataset2} do assert Dataset.delete_default_graph(dataset1) == Dataset.new() assert Dataset.delete_default_graph(dataset2) == Dataset.new({EX.S2, EX.p2(), EX.O2, EX.Graph}) end test "a single graph", %{dataset1: dataset1, dataset2: dataset2} do assert Dataset.delete_graph(dataset1, EX.Graph) == dataset1 assert Dataset.delete_graph(dataset2, EX.Graph) == dataset1 end test "a list of graphs", %{dataset1: dataset1, dataset3: dataset3} do assert Dataset.delete_graph(dataset3, [EX.Graph1, EX.Graph2]) == dataset1 assert Dataset.delete_graph(dataset3, [EX.Graph1, EX.Graph2, EX.Graph3]) == dataset1 assert Dataset.delete_graph(dataset3, [EX.Graph1, EX.Graph2, nil]) == Dataset.new() end end test "pop" do assert Dataset.pop(Dataset.new()) == {nil, Dataset.new()} {quad, dataset} = Dataset.new({EX.S, EX.p(), EX.O, EX.Graph}) |> Dataset.pop() assert quad == {iri(EX.S), iri(EX.p()), iri(EX.O), iri(EX.Graph)} assert Enum.count(dataset.graphs) == 0 {{subject, predicate, object, _}, dataset} = Dataset.new([{EX.S, EX.p(), EX.O, EX.Graph}, {EX.S, EX.p(), EX.O}]) |> Dataset.pop() assert {subject, predicate, object} == {iri(EX.S), iri(EX.p()), iri(EX.O)} assert Enum.count(dataset.graphs) == 1 {{subject, _, _, graph_context}, dataset} = Dataset.new([{EX.S, EX.p(), EX.O1, EX.Graph}, {EX.S, EX.p(), EX.O2, EX.Graph}]) |> Dataset.pop() assert subject == iri(EX.S) assert graph_context == iri(EX.Graph) assert Enum.count(dataset.graphs) == 1 end test "statement_count/1" do assert Dataset.statement_count(dataset()) == 0 assert Dataset.statement_count(Dataset.new(statement())) == 1 end test "empty?/1" do assert Dataset.empty?(dataset()) == true assert Dataset.empty?(Dataset.new(statement())) == false assert Dataset.empty?(Dataset.new(graph())) == true end describe "include?/3" do test "valid cases" do dataset = Dataset.new([ {EX.S1, EX.p(), EX.O1}, {EX.S2, EX.p(), EX.O2, EX.Graph} ]) assert Dataset.include?(dataset, {EX.S1, EX.p(), EX.O1}) refute Dataset.include?(dataset, {EX.S2, EX.p(), EX.O2}) assert Dataset.include?(dataset, {EX.S2, EX.p(), EX.O2, EX.Graph}) assert Dataset.include?(dataset, {EX.S2, EX.p(), EX.O2}, graph: EX.Graph) assert Dataset.include?(dataset, [{EX.S1, EX.p(), EX.O1}]) assert Dataset.include?(dataset, [{EX.S2, EX.p(), EX.O2}], graph: EX.Graph) assert Dataset.include?(dataset, [ {EX.S1, EX.p(), EX.O1}, {EX.S2, EX.p(), EX.O2, EX.Graph} ]) refute Dataset.include?(dataset, [ {EX.S1, EX.p(), EX.O1}, {EX.S2, EX.p(), EX.O2} ]) assert Dataset.include?(dataset, EX.S1 |> EX.p(EX.O1)) refute Dataset.include?(dataset, EX.S2 |> EX.p(EX.O2)) assert Dataset.include?(dataset, EX.p(EX.S2, EX.O2), graph: EX.Graph) assert Dataset.include?(dataset, Graph.new(EX.S1 |> EX.p(EX.O1))) assert Dataset.include?(dataset, dataset) assert Dataset.include?( dataset, [ {EX.S1, :p, EX.O1}, {EX.S2, :p, EX.O2, EX.Graph} ], context: [p: EX.p()] ) end test "structs are causing an error" do assert_raise FunctionClauseError, fn -> Dataset.include?(dataset(), Date.utc_today()) end end end test "values/1" do assert Dataset.new() |> Dataset.values() == %{} assert Dataset.new([{EX.s1(), EX.p(), EX.o1()}, {EX.s2(), EX.p(), EX.o2(), EX.graph()}]) |> Dataset.values() == %{ nil => %{ RDF.Term.value(EX.s1()) => %{RDF.Term.value(EX.p()) => [RDF.Term.value(EX.o1())]} }, RDF.Term.value(EX.graph()) => %{ RDF.Term.value(EX.s2()) => %{RDF.Term.value(EX.p()) => [RDF.Term.value(EX.o2())]} } } end test "values/2" do expected_result = %{ nil => %{ RDF.Term.value(EX.s1()) => %{p: [RDF.Term.value(EX.o1())]} }, RDF.Term.value(EX.graph()) => %{ RDF.Term.value(EX.s2()) => %{p: [RDF.Term.value(EX.o2())]} } } assert Dataset.new([{EX.s1(), EX.p(), EX.o1()}, {EX.s2(), EX.p(), EX.o2(), EX.graph()}]) |> Dataset.values(context: PropertyMap.new(p: EX.p())) == expected_result assert Dataset.new([{EX.s1(), EX.p(), EX.o1()}, {EX.s2(), EX.p(), EX.o2(), EX.graph()}]) |> Dataset.values(context: %{p: EX.p()}) == expected_result end test "map/2" do mapping = fn {:graph_name, graph_name} -> graph_name {:predicate, predicate} -> predicate |> to_string() |> String.split("/") |> List.last() |> String.to_atom() {_, term} -> RDF.Term.value(term) end assert Dataset.new() |> Dataset.map(mapping) == %{} assert Dataset.new([{EX.s1(), EX.p(), EX.o1()}, {EX.s2(), EX.p(), EX.o2(), EX.graph()}]) |> Dataset.map(mapping) == %{ nil => %{ RDF.Term.value(EX.s1()) => %{p: [RDF.Term.value(EX.o1())]} }, EX.graph() => %{ RDF.Term.value(EX.s2()) => %{p: [RDF.Term.value(EX.o2())]} } } end test "equal/2" do triple = {EX.S, EX.p(), EX.O} assert Dataset.equal?(Dataset.new(triple), Dataset.new(triple)) assert Dataset.equal?( Dataset.new(triple, name: EX.Dataset1), Dataset.new(triple, name: EX.Dataset1) ) assert Dataset.equal?( Dataset.new(Graph.new(triple, name: EX.Graph1, prefixes: %{ex: EX})), Dataset.new(Graph.new(triple, name: EX.Graph1, prefixes: %{ex: RDF})) ) assert Dataset.equal?( Dataset.new(Graph.new(triple, name: EX.Graph1, base_iri: EX.base())), Dataset.new(Graph.new(triple, name: EX.Graph1, base_iri: EX.other_base())) ) refute Dataset.equal?(Dataset.new(triple), Dataset.new({EX.S, EX.p(), EX.O2})) refute Dataset.equal?( Dataset.new(triple, name: EX.Dataset1), Dataset.new(triple, name: EX.Dataset2) ) refute Dataset.equal?( Dataset.new(Graph.new(triple, name: EX.Graph1)), Dataset.new(Graph.new(triple, name: EX.Graph2)) ) end test "prefixes/1" do assert Dataset.new() |> Dataset.add(Graph.new(prefixes: [ex: EX, foo: RDFS])) |> Dataset.add(Graph.new(name: EX.Graph, prefixes: [ex: EX, foo: OWL])) |> Dataset.prefixes() == PrefixMap.new(ex: EX, foo: RDFS) end test "statements/1" do assert Dataset.new([ {EX.S1, EX.p1(), EX.O1}, {EX.S1, EX.p2(), EX.O2}, {EX.S1, EX.p2(), EX.O2, EX.GraphName}, {EX.S2, EX.p2(), EX.O2, EX.GraphName} ]) |> Dataset.statements() == [ {RDF.iri(EX.S1), EX.p1(), RDF.iri(EX.O1)}, {RDF.iri(EX.S1), EX.p2(), RDF.iri(EX.O2)}, {RDF.iri(EX.S1), EX.p2(), RDF.iri(EX.O2), RDF.iri(EX.GraphName)}, {RDF.iri(EX.S2), EX.p2(), RDF.iri(EX.O2), RDF.iri(EX.GraphName)} ] end describe "Enumerable protocol" do test "Enum.count" do assert Enum.count(Dataset.new(name: EX.foo())) == 0 assert Enum.count(Dataset.new({EX.S, EX.p(), EX.O, EX.Graph})) == 1 assert Enum.count(Dataset.new([{EX.S, EX.p(), EX.O1, EX.Graph}, {EX.S, EX.p(), EX.O2}])) == 2 ds = Dataset.add(dataset(), [ {EX.Subject1, EX.predicate1(), EX.Object1, EX.Graph}, {EX.Subject1, EX.predicate2(), EX.Object2, EX.Graph}, {EX.Subject3, EX.predicate3(), EX.Object3} ]) assert Enum.count(ds) == 3 end test "Enum.member?" do refute Enum.member?(Dataset.new(), {iri(EX.S), EX.p(), iri(EX.O), iri(EX.Graph)}) assert Enum.member?( Dataset.new({EX.S, EX.p(), EX.O, EX.Graph}), {EX.S, EX.p(), EX.O, EX.Graph} ) ds = Dataset.add(dataset(), [ {EX.Subject1, EX.predicate1(), EX.Object1, EX.Graph}, {EX.Subject1, EX.predicate2(), EX.Object2, EX.Graph}, {EX.Subject3, EX.predicate3(), EX.Object3} ]) assert Enum.member?(ds, {EX.Subject1, EX.predicate1(), EX.Object1, EX.Graph}) assert Enum.member?(ds, {EX.Subject1, EX.predicate2(), EX.Object2, EX.Graph}) assert Enum.member?(ds, {EX.Subject3, EX.predicate3(), EX.Object3}) end test "Enum.reduce" do ds = Dataset.add(dataset(), [ {EX.Subject1, EX.predicate1(), EX.Object1, EX.Graph}, {EX.Subject1, EX.predicate2(), EX.Object2}, {EX.Subject3, EX.predicate3(), EX.Object3, EX.Graph} ]) assert ds == Enum.reduce(ds, dataset(), fn statement, acc -> acc |> Dataset.add(statement) end) end test "Enum.at (for Enumerable.slice/1)" do assert Dataset.new({EX.S, EX.p(), EX.O, EX.Graph}) |> Enum.at(0) == {RDF.iri(EX.S), EX.p(), RDF.iri(EX.O), RDF.iri(EX.Graph)} end end describe "Collectable protocol" do test "with a list of triples" do triples = [ {EX.Subject, EX.predicate1(), EX.Object1}, {EX.Subject, EX.predicate2(), EX.Object2}, {EX.Subject, EX.predicate2(), EX.Object2, EX.Graph} ] assert Enum.into(triples, Dataset.new()) == Dataset.new(triples) end test "with a list of lists" do lists = [ [EX.Subject, EX.predicate1(), EX.Object1], [EX.Subject, EX.predicate2(), EX.Object2], [EX.Subject, EX.predicate2(), EX.Object2, EX.Graph] ] assert Enum.into(lists, Dataset.new()) == Dataset.new(Enum.map(lists, &List.to_tuple/1)) end end describe "Access behaviour" do test "access with the [] operator" do assert Dataset.new()[EX.Graph] == nil assert Dataset.new({EX.S, EX.p(), EX.O, EX.Graph})[EX.Graph] == Graph.new({EX.S, EX.p(), EX.O}, name: EX.Graph) end end end