1145 lines
34 KiB
Elixir
1145 lines
34 KiB
Elixir
defmodule JSON.LD.ExpansionTest do
|
|
use ExUnit.Case, async: false
|
|
|
|
import JSON.LD.Expansion, only: [expand_value: 3]
|
|
|
|
alias RDF.NS.{RDFS, XSD}
|
|
|
|
test "Expanded form of a JSON-LD document (EXAMPLE 55 and 56 of https://www.w3.org/TR/json-ld/#expanded-document-form)" do
|
|
input =
|
|
Jason.decode!("""
|
|
{
|
|
"@context":
|
|
{
|
|
"name": "http://xmlns.com/foaf/0.1/name",
|
|
"homepage": {
|
|
"@id": "http://xmlns.com/foaf/0.1/homepage",
|
|
"@type": "@id"
|
|
}
|
|
},
|
|
"name": "Manu Sporny",
|
|
"homepage": "http://manu.sporny.org/"
|
|
}
|
|
""")
|
|
|
|
assert JSON.LD.expand(input) ==
|
|
Jason.decode!("""
|
|
[
|
|
{
|
|
"http://xmlns.com/foaf/0.1/name": [
|
|
{ "@value": "Manu Sporny" }
|
|
],
|
|
"http://xmlns.com/foaf/0.1/homepage": [
|
|
{ "@id": "http://manu.sporny.org/" }
|
|
]
|
|
}
|
|
]
|
|
""")
|
|
end
|
|
|
|
%{
|
|
"empty doc" => %{
|
|
input: %{},
|
|
output: []
|
|
},
|
|
"@list coercion" => %{
|
|
input: %{
|
|
"@context" => %{
|
|
"foo" => %{"@id" => "http://example.com/foo", "@container" => "@list"}
|
|
},
|
|
"foo" => [%{"@value" => "bar"}]
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.com/foo" => [%{"@list" => [%{"@value" => "bar"}]}]
|
|
}
|
|
]
|
|
},
|
|
"native values in list" => %{
|
|
input: %{
|
|
"http://example.com/foo" => %{"@list" => [1, 2]}
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.com/foo" => [%{"@list" => [%{"@value" => 1}, %{"@value" => 2}]}]
|
|
}
|
|
]
|
|
},
|
|
"@graph" => %{
|
|
input: %{
|
|
"@context" => %{"ex" => "http://example.com/"},
|
|
"@graph" => [
|
|
%{"ex:foo" => %{"@value" => "foo"}},
|
|
%{"ex:bar" => %{"@value" => "bar"}}
|
|
]
|
|
},
|
|
output: [
|
|
%{"http://example.com/foo" => [%{"@value" => "foo"}]},
|
|
%{"http://example.com/bar" => [%{"@value" => "bar"}]}
|
|
]
|
|
},
|
|
"@type with CURIE" => %{
|
|
input: %{
|
|
"@context" => %{"ex" => "http://example.com/"},
|
|
"@type" => "ex:type"
|
|
},
|
|
output: [
|
|
%{"@type" => ["http://example.com/type"]}
|
|
]
|
|
},
|
|
"@type with CURIE and muliple values" => %{
|
|
input: %{
|
|
"@context" => %{"ex" => "http://example.com/"},
|
|
"@type" => ["ex:type1", "ex:type2"]
|
|
},
|
|
output: [
|
|
%{"@type" => ["http://example.com/type1", "http://example.com/type2"]}
|
|
]
|
|
},
|
|
"@value with false" => %{
|
|
input: %{"http://example.com/ex" => %{"@value" => false}},
|
|
output: [%{"http://example.com/ex" => [%{"@value" => false}]}]
|
|
}
|
|
}
|
|
|> Enum.each(fn {title, data} ->
|
|
@tag data: data
|
|
test title, %{data: data} do
|
|
assert JSON.LD.expand(data.input) == data.output
|
|
end
|
|
end)
|
|
|
|
describe "with relative IRIs" do
|
|
%{
|
|
"base" => %{
|
|
input: %{
|
|
"@id" => "",
|
|
"@type" => RDFS.Resource |> RDF.uri() |> to_string
|
|
},
|
|
output: [
|
|
%{
|
|
"@id" => "http://example.org/",
|
|
"@type" => [RDFS.Resource |> RDF.uri() |> to_string]
|
|
}
|
|
]
|
|
},
|
|
"relative" => %{
|
|
input: %{
|
|
"@id" => "a/b",
|
|
"@type" => RDFS.Resource |> RDF.uri() |> to_string
|
|
},
|
|
output: [
|
|
%{
|
|
"@id" => "http://example.org/a/b",
|
|
"@type" => [RDFS.Resource |> RDF.uri() |> to_string]
|
|
}
|
|
]
|
|
},
|
|
"hash" => %{
|
|
input: %{
|
|
"@id" => "#a",
|
|
"@type" => RDFS.Resource |> RDF.uri() |> to_string
|
|
},
|
|
output: [
|
|
%{
|
|
"@id" => "http://example.org/#a",
|
|
"@type" => [RDFS.Resource |> RDF.uri() |> to_string]
|
|
}
|
|
]
|
|
},
|
|
"unmapped @id" => %{
|
|
input: %{
|
|
"http://example.com/foo" => %{"@id" => "bar"}
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.com/foo" => [%{"@id" => "http://example.org/bar"}]
|
|
}
|
|
]
|
|
}
|
|
}
|
|
|> Enum.each(fn {title, data} ->
|
|
@tag data: data
|
|
test title, %{data: data} do
|
|
assert JSON.LD.expand(data.input, base: "http://example.org/") == data.output
|
|
end
|
|
end)
|
|
end
|
|
|
|
describe "keyword aliasing" do
|
|
%{
|
|
"@id" => %{
|
|
input: %{
|
|
"@context" => %{"id" => "@id"},
|
|
"id" => "",
|
|
"@type" => RDFS.Resource |> RDF.uri() |> to_string
|
|
},
|
|
output: [
|
|
%{
|
|
"@id" => "",
|
|
"@type" => [RDFS.Resource |> RDF.uri() |> to_string]
|
|
}
|
|
]
|
|
},
|
|
"@type" => %{
|
|
input: %{
|
|
"@context" => %{"type" => "@type"},
|
|
"type" => RDFS.Resource |> RDF.uri() |> to_string,
|
|
"http://example.com/foo" => %{"@value" => "bar", "type" => "http://example.com/baz"}
|
|
},
|
|
output: [
|
|
%{
|
|
"@type" => [RDFS.Resource |> RDF.uri() |> to_string],
|
|
"http://example.com/foo" => [
|
|
%{"@value" => "bar", "@type" => "http://example.com/baz"}
|
|
]
|
|
}
|
|
]
|
|
},
|
|
"@language" => %{
|
|
input: %{
|
|
"@context" => %{"language" => "@language"},
|
|
"http://example.com/foo" => %{"@value" => "bar", "language" => "baz"}
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.com/foo" => [%{"@value" => "bar", "@language" => "baz"}]
|
|
}
|
|
]
|
|
},
|
|
"@value" => %{
|
|
input: %{
|
|
"@context" => %{"literal" => "@value"},
|
|
"http://example.com/foo" => %{"literal" => "bar"}
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.com/foo" => [%{"@value" => "bar"}]
|
|
}
|
|
]
|
|
},
|
|
"@list" => %{
|
|
input: %{
|
|
"@context" => %{"list" => "@list"},
|
|
"http://example.com/foo" => %{"list" => ["bar"]}
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.com/foo" => [%{"@list" => [%{"@value" => "bar"}]}]
|
|
}
|
|
]
|
|
}
|
|
}
|
|
|> Enum.each(fn {title, data} ->
|
|
@tag data: data
|
|
test title, %{data: data} do
|
|
assert JSON.LD.expand(data.input) == data.output
|
|
end
|
|
end)
|
|
end
|
|
|
|
describe "native types" do
|
|
%{
|
|
"true" => %{
|
|
input: %{
|
|
"@context" => %{"e" => "http://example.org/vocab#"},
|
|
"e:bool" => true
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.org/vocab#bool" => [%{"@value" => true}]
|
|
}
|
|
]
|
|
},
|
|
"false" => %{
|
|
input: %{
|
|
"@context" => %{"e" => "http://example.org/vocab#"},
|
|
"e:bool" => false
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.org/vocab#bool" => [%{"@value" => false}]
|
|
}
|
|
]
|
|
},
|
|
"double" => %{
|
|
input: %{
|
|
"@context" => %{"e" => "http://example.org/vocab#"},
|
|
"e:double" => 1.23
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.org/vocab#double" => [%{"@value" => 1.23}]
|
|
}
|
|
]
|
|
},
|
|
"double-zero" => %{
|
|
input: %{
|
|
"@context" => %{"e" => "http://example.org/vocab#"},
|
|
"e:double-zero" => 0.0e0
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.org/vocab#double-zero" => [%{"@value" => 0.0e0}]
|
|
}
|
|
]
|
|
},
|
|
"integer" => %{
|
|
input: %{
|
|
"@context" => %{"e" => "http://example.org/vocab#"},
|
|
"e:integer" => 123
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.org/vocab#integer" => [%{"@value" => 123}]
|
|
}
|
|
]
|
|
}
|
|
}
|
|
|> Enum.each(fn {title, data} ->
|
|
@tag data: data
|
|
test title, %{data: data} do
|
|
assert JSON.LD.expand(data.input) == data.output
|
|
end
|
|
end)
|
|
end
|
|
|
|
describe "coerced typed values" do
|
|
%{
|
|
"boolean" => %{
|
|
input: %{
|
|
"@context" => %{
|
|
"foo" => %{"@id" => "http://example.org/foo", "@type" => to_string(XSD.boolean())}
|
|
},
|
|
"foo" => "true"
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.org/foo" => [
|
|
%{"@value" => "true", "@type" => to_string(XSD.boolean())}
|
|
]
|
|
}
|
|
]
|
|
},
|
|
"date" => %{
|
|
input: %{
|
|
"@context" => %{
|
|
"foo" => %{"@id" => "http://example.org/foo", "@type" => to_string(XSD.date())}
|
|
},
|
|
"foo" => "2011-03-26"
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.org/foo" => [
|
|
%{"@value" => "2011-03-26", "@type" => to_string(XSD.date())}
|
|
]
|
|
}
|
|
]
|
|
}
|
|
}
|
|
|> Enum.each(fn {title, data} ->
|
|
@tag data: data
|
|
test title, %{data: data} do
|
|
assert JSON.LD.expand(data.input) == data.output
|
|
end
|
|
end)
|
|
end
|
|
|
|
describe "null" do
|
|
%{
|
|
"value" => %{
|
|
input: %{"http://example.com/foo" => nil},
|
|
output: []
|
|
},
|
|
"@value" => %{
|
|
input: %{"http://example.com/foo" => %{"@value" => nil}},
|
|
output: []
|
|
},
|
|
"@value and non-null @type" => %{
|
|
input: %{"http://example.com/foo" => %{"@value" => nil, "@type" => "http://type"}},
|
|
output: []
|
|
},
|
|
"@value and non-null @language" => %{
|
|
input: %{"http://example.com/foo" => %{"@value" => nil, "@language" => "en"}},
|
|
output: []
|
|
},
|
|
"array with null elements" => %{
|
|
input: %{
|
|
"http://example.com/foo" => [nil]
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.com/foo" => []
|
|
}
|
|
]
|
|
},
|
|
"@set with null @value" => %{
|
|
input: %{
|
|
"http://example.com/foo" => [
|
|
%{"@value" => nil, "@type" => "http://example.org/Type"}
|
|
]
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.com/foo" => []
|
|
}
|
|
]
|
|
}
|
|
}
|
|
|> Enum.each(fn {title, data} ->
|
|
@tag data: data
|
|
test title, %{data: data} do
|
|
assert JSON.LD.expand(data.input) == data.output
|
|
end
|
|
end)
|
|
end
|
|
|
|
describe "default language" do
|
|
%{
|
|
"value with coerced null language" => %{
|
|
input: %{
|
|
"@context" => %{
|
|
"@language" => "en",
|
|
"ex" => "http://example.org/vocab#",
|
|
"ex:german" => %{"@language" => "de"},
|
|
"ex:nolang" => %{"@language" => nil}
|
|
},
|
|
"ex:german" => "german",
|
|
"ex:nolang" => "no language"
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.org/vocab#german" => [%{"@value" => "german", "@language" => "de"}],
|
|
"http://example.org/vocab#nolang" => [%{"@value" => "no language"}]
|
|
}
|
|
]
|
|
}
|
|
}
|
|
|> Enum.each(fn {title, data} ->
|
|
@tag data: data
|
|
test title, %{data: data} do
|
|
assert JSON.LD.expand(data.input) == data.output
|
|
end
|
|
end)
|
|
end
|
|
|
|
describe "default vocabulary" do
|
|
%{
|
|
"property" => %{
|
|
input: %{
|
|
"@context" => %{"@vocab" => "http://example.com/"},
|
|
"verb" => %{"@value" => "foo"}
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.com/verb" => [%{"@value" => "foo"}]
|
|
}
|
|
]
|
|
},
|
|
"datatype" => %{
|
|
input: %{
|
|
"@context" => %{"@vocab" => "http://example.com/"},
|
|
"http://example.org/verb" => %{"@value" => "foo", "@type" => "string"}
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.org/verb" => [
|
|
%{"@value" => "foo", "@type" => "http://example.com/string"}
|
|
]
|
|
}
|
|
]
|
|
},
|
|
"expand-0028" => %{
|
|
input: %{
|
|
"@context" => %{
|
|
"@vocab" => "http://example.org/vocab#",
|
|
"date" => %{"@type" => "dateTime"}
|
|
},
|
|
"@id" => "example1",
|
|
"@type" => "test",
|
|
"date" => "2011-01-25T00:00:00Z",
|
|
"embed" => %{
|
|
"@id" => "example2",
|
|
"expandedDate" => %{"@value" => "2012-08-01T00:00:00Z", "@type" => "dateTime"}
|
|
}
|
|
},
|
|
output: [
|
|
%{
|
|
"@id" => "http://foo/bar/example1",
|
|
"@type" => ["http://example.org/vocab#test"],
|
|
"http://example.org/vocab#date" => [
|
|
%{
|
|
"@value" => "2011-01-25T00:00:00Z",
|
|
"@type" => "http://example.org/vocab#dateTime"
|
|
}
|
|
],
|
|
"http://example.org/vocab#embed" => [
|
|
%{
|
|
"@id" => "http://foo/bar/example2",
|
|
"http://example.org/vocab#expandedDate" => [
|
|
%{
|
|
"@value" => "2012-08-01T00:00:00Z",
|
|
"@type" => "http://example.org/vocab#dateTime"
|
|
}
|
|
]
|
|
}
|
|
]
|
|
}
|
|
]
|
|
}
|
|
}
|
|
|> Enum.each(fn {title, data} ->
|
|
@tag data: data
|
|
test title, %{data: data} do
|
|
assert JSON.LD.expand(data.input, base: "http://foo/bar/") == data.output
|
|
end
|
|
end)
|
|
end
|
|
|
|
describe "unmapped properties" do
|
|
%{
|
|
"unmapped key" => %{
|
|
input: %{
|
|
"foo" => "bar"
|
|
},
|
|
output: []
|
|
},
|
|
"unmapped @type as datatype" => %{
|
|
input: %{
|
|
"http://example.com/foo" => %{"@value" => "bar", "@type" => "baz"}
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.com/foo" => [%{"@value" => "bar", "@type" => "http://example/baz"}]
|
|
}
|
|
]
|
|
},
|
|
"unknown keyword" => %{
|
|
input: %{
|
|
"@foo" => "bar"
|
|
},
|
|
output: []
|
|
},
|
|
"value" => %{
|
|
input: %{
|
|
"@context" => %{"ex" => %{"@id" => "http://example.org/idrange", "@type" => "@id"}},
|
|
"@id" => "http://example.org/Subj",
|
|
"idrange" => "unmapped"
|
|
},
|
|
output: []
|
|
},
|
|
"context reset" => %{
|
|
input: %{
|
|
"@context" => %{"ex" => "http://example.org/", "prop" => "ex:prop"},
|
|
"@id" => "http://example.org/id1",
|
|
"prop" => "prop",
|
|
"ex:chain" => %{
|
|
"@context" => nil,
|
|
"@id" => "http://example.org/id2",
|
|
"prop" => "prop"
|
|
}
|
|
},
|
|
output: [
|
|
%{
|
|
"@id" => "http://example.org/id1",
|
|
"http://example.org/prop" => [%{"@value" => "prop"}],
|
|
"http://example.org/chain" => [%{"@id" => "http://example.org/id2"}]
|
|
}
|
|
]
|
|
}
|
|
}
|
|
|> Enum.each(fn {title, data} ->
|
|
@tag data: data
|
|
test title, %{data: data} do
|
|
assert JSON.LD.expand(data.input, base: "http://example/") == data.output
|
|
end
|
|
end)
|
|
end
|
|
|
|
describe "lists" do
|
|
%{
|
|
"empty" => %{
|
|
input: %{"http://example.com/foo" => %{"@list" => []}},
|
|
output: [%{"http://example.com/foo" => [%{"@list" => []}]}]
|
|
},
|
|
"coerced empty" => %{
|
|
input: %{
|
|
"@context" => %{"http://example.com/foo" => %{"@container" => "@list"}},
|
|
"http://example.com/foo" => []
|
|
},
|
|
output: [%{"http://example.com/foo" => [%{"@list" => []}]}]
|
|
},
|
|
"coerced single element" => %{
|
|
input: %{
|
|
"@context" => %{"http://example.com/foo" => %{"@container" => "@list"}},
|
|
"http://example.com/foo" => ["foo"]
|
|
},
|
|
output: [%{"http://example.com/foo" => [%{"@list" => [%{"@value" => "foo"}]}]}]
|
|
},
|
|
"coerced multiple elements" => %{
|
|
input: %{
|
|
"@context" => %{"http://example.com/foo" => %{"@container" => "@list"}},
|
|
"http://example.com/foo" => ["foo", "bar"]
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.com/foo" => [
|
|
%{"@list" => [%{"@value" => "foo"}, %{"@value" => "bar"}]}
|
|
]
|
|
}
|
|
]
|
|
},
|
|
"explicit list with coerced @id values" => %{
|
|
input: %{
|
|
"@context" => %{"http://example.com/foo" => %{"@type" => "@id"}},
|
|
"http://example.com/foo" => %{"@list" => ["http://foo", "http://bar"]}
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.com/foo" => [
|
|
%{"@list" => [%{"@id" => "http://foo"}, %{"@id" => "http://bar"}]}
|
|
]
|
|
}
|
|
]
|
|
},
|
|
"explicit list with coerced datatype values" => %{
|
|
input: %{
|
|
"@context" => %{"http://example.com/foo" => %{"@type" => to_string(XSD.date())}},
|
|
"http://example.com/foo" => %{"@list" => ["2012-04-12"]}
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.com/foo" => [
|
|
%{"@list" => [%{"@value" => "2012-04-12", "@type" => to_string(XSD.date())}]}
|
|
]
|
|
}
|
|
]
|
|
},
|
|
"expand-0004" => %{
|
|
input: Jason.decode!(~s({
|
|
"@context": {
|
|
"mylist1": {"@id": "http://example.com/mylist1", "@container": "@list"},
|
|
"mylist2": {"@id": "http://example.com/mylist2", "@container": "@list"},
|
|
"myset2": {"@id": "http://example.com/myset2", "@container": "@set"},
|
|
"myset3": {"@id": "http://example.com/myset3", "@container": "@set"}
|
|
},
|
|
"http://example.org/property": { "@list": "one item" }
|
|
})),
|
|
output: Jason.decode!(~s([
|
|
{
|
|
"http://example.org/property": [
|
|
{
|
|
"@list": [
|
|
{
|
|
"@value": "one item"
|
|
}
|
|
]
|
|
}
|
|
]
|
|
}
|
|
]))
|
|
}
|
|
}
|
|
|> Enum.each(fn {title, data} ->
|
|
@tag data: data
|
|
test title, %{data: data} do
|
|
assert JSON.LD.expand(data.input) == data.output
|
|
end
|
|
end)
|
|
end
|
|
|
|
describe "sets" do
|
|
%{
|
|
"empty" => %{
|
|
input: %{
|
|
"http://example.com/foo" => %{"@set" => []}
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.com/foo" => []
|
|
}
|
|
]
|
|
},
|
|
"coerced empty" => %{
|
|
input: %{
|
|
"@context" => %{"http://example.com/foo" => %{"@container" => "@set"}},
|
|
"http://example.com/foo" => []
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.com/foo" => []
|
|
}
|
|
]
|
|
},
|
|
"coerced single element" => %{
|
|
input: %{
|
|
"@context" => %{"http://example.com/foo" => %{"@container" => "@set"}},
|
|
"http://example.com/foo" => ["foo"]
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.com/foo" => [%{"@value" => "foo"}]
|
|
}
|
|
]
|
|
},
|
|
"coerced multiple elements" => %{
|
|
input: %{
|
|
"@context" => %{"http://example.com/foo" => %{"@container" => "@set"}},
|
|
"http://example.com/foo" => ["foo", "bar"]
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.com/foo" => [%{"@value" => "foo"}, %{"@value" => "bar"}]
|
|
}
|
|
]
|
|
},
|
|
"array containing set" => %{
|
|
input: %{
|
|
"http://example.com/foo" => [%{"@set" => []}]
|
|
},
|
|
output: [
|
|
%{
|
|
"http://example.com/foo" => []
|
|
}
|
|
]
|
|
}
|
|
}
|
|
|> Enum.each(fn {title, data} ->
|
|
@tag data: data
|
|
test title, %{data: data} do
|
|
assert JSON.LD.expand(data.input) == data.output
|
|
end
|
|
end)
|
|
end
|
|
|
|
describe "language maps" do
|
|
%{
|
|
"simple map" => %{
|
|
input: %{
|
|
"@context" => %{
|
|
"vocab" => "http://example.com/vocab/",
|
|
"label" => %{
|
|
"@id" => "vocab:label",
|
|
"@container" => "@language"
|
|
}
|
|
},
|
|
"@id" => "http://example.com/queen",
|
|
"label" => %{
|
|
"en" => "The Queen",
|
|
"de" => ["Die Königin", "Ihre Majestät"]
|
|
}
|
|
},
|
|
output: [
|
|
%{
|
|
"@id" => "http://example.com/queen",
|
|
"http://example.com/vocab/label" => [
|
|
%{"@value" => "Die Königin", "@language" => "de"},
|
|
%{"@value" => "Ihre Majestät", "@language" => "de"},
|
|
%{"@value" => "The Queen", "@language" => "en"}
|
|
]
|
|
}
|
|
]
|
|
}
|
|
# TODO: Only the order of result is not correct, the content seems ok (although
|
|
# it's not clear why, since the "http://example.com/vocab/label" object is not handled in 7.5 code (at least debug statement are not printed
|
|
# "expand-0035" => %{
|
|
# input: %{
|
|
# "@context" => %{
|
|
# "@vocab" => "http://example.com/vocab/",
|
|
# "@language" => "it",
|
|
# "label" => %{
|
|
# "@container" => "@language"
|
|
# }
|
|
# },
|
|
# "@id" => "http://example.com/queen",
|
|
# "label" => %{
|
|
# "en" => "The Queen",
|
|
# "de" => [ "Die Königin", "Ihre Majestät" ]
|
|
# },
|
|
# "http://example.com/vocab/label" => [
|
|
# "Il re",
|
|
# %{ "@value" => "The king", "@language" => "en" }
|
|
# ]
|
|
# },
|
|
# output: [
|
|
# %{
|
|
# "@id" => "http://example.com/queen",
|
|
# "http://example.com/vocab/label" => [
|
|
# %{"@value" => "Il re", "@language" => "it"},
|
|
# %{"@value" => "The king", "@language" => "en"},
|
|
# %{"@value" => "Die Königin", "@language" => "de"},
|
|
# %{"@value" => "Ihre Majestät", "@language" => "de"},
|
|
# %{"@value" => "The Queen", "@language" => "en"},
|
|
# ]
|
|
# }
|
|
# ]
|
|
# }
|
|
}
|
|
|> Enum.each(fn {title, data} ->
|
|
@tag data: data
|
|
test title, %{data: data} do
|
|
assert JSON.LD.expand(data.input) == data.output
|
|
end
|
|
end)
|
|
end
|
|
|
|
describe "@reverse" do
|
|
%{
|
|
"expand-0037" => %{
|
|
input: Jason.decode!(~s({
|
|
"@context": {
|
|
"name": "http://xmlns.com/foaf/0.1/name"
|
|
},
|
|
"@id": "http://example.com/people/markus",
|
|
"name": "Markus Lanthaler",
|
|
"@reverse": {
|
|
"http://xmlns.com/foaf/0.1/knows": {
|
|
"@id": "http://example.com/people/dave",
|
|
"name": "Dave Longley"
|
|
}
|
|
}
|
|
})),
|
|
output: Jason.decode!(~s([
|
|
{
|
|
"@id": "http://example.com/people/markus",
|
|
"@reverse": {
|
|
"http://xmlns.com/foaf/0.1/knows": [
|
|
{
|
|
"@id": "http://example.com/people/dave",
|
|
"http://xmlns.com/foaf/0.1/name": [
|
|
{
|
|
"@value": "Dave Longley"
|
|
}
|
|
]
|
|
}
|
|
]
|
|
},
|
|
"http://xmlns.com/foaf/0.1/name": [
|
|
{
|
|
"@value": "Markus Lanthaler"
|
|
}
|
|
]
|
|
}
|
|
]))
|
|
},
|
|
"expand-0043" => %{
|
|
input: Jason.decode!(~s({
|
|
"@context": {
|
|
"name": "http://xmlns.com/foaf/0.1/name",
|
|
"isKnownBy": { "@reverse": "http://xmlns.com/foaf/0.1/knows" }
|
|
},
|
|
"@id": "http://example.com/people/markus",
|
|
"name": "Markus Lanthaler",
|
|
"@reverse": {
|
|
"isKnownBy": [
|
|
{
|
|
"@id": "http://example.com/people/dave",
|
|
"name": "Dave Longley"
|
|
},
|
|
{
|
|
"@id": "http://example.com/people/gregg",
|
|
"name": "Gregg Kellogg"
|
|
}
|
|
]
|
|
}
|
|
})),
|
|
output: Jason.decode!(~s([
|
|
{
|
|
"@id": "http://example.com/people/markus",
|
|
"http://xmlns.com/foaf/0.1/knows": [
|
|
{
|
|
"@id": "http://example.com/people/dave",
|
|
"http://xmlns.com/foaf/0.1/name": [
|
|
{
|
|
"@value": "Dave Longley"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
"@id": "http://example.com/people/gregg",
|
|
"http://xmlns.com/foaf/0.1/name": [
|
|
{
|
|
"@value": "Gregg Kellogg"
|
|
}
|
|
]
|
|
}
|
|
],
|
|
"http://xmlns.com/foaf/0.1/name": [
|
|
{
|
|
"@value": "Markus Lanthaler"
|
|
}
|
|
]
|
|
}
|
|
]))
|
|
}
|
|
}
|
|
|> Enum.each(fn {title, data} ->
|
|
@tag data: data
|
|
test title, %{data: data} do
|
|
assert JSON.LD.expand(data.input) == data.output
|
|
end
|
|
end)
|
|
end
|
|
|
|
describe "@index" do
|
|
%{
|
|
"string annotation" => %{
|
|
input: %{
|
|
"@context" => %{
|
|
"container" => %{
|
|
"@id" => "http://example.com/container",
|
|
"@container" => "@index"
|
|
}
|
|
},
|
|
"@id" => "http://example.com/annotationsTest",
|
|
"container" => %{
|
|
"en" => "The Queen",
|
|
"de" => ["Die Königin", "Ihre Majestät"]
|
|
}
|
|
},
|
|
output: [
|
|
%{
|
|
"@id" => "http://example.com/annotationsTest",
|
|
"http://example.com/container" => [
|
|
%{"@value" => "Die Königin", "@index" => "de"},
|
|
%{"@value" => "Ihre Majestät", "@index" => "de"},
|
|
%{"@value" => "The Queen", "@index" => "en"}
|
|
]
|
|
}
|
|
]
|
|
}
|
|
}
|
|
|> Enum.each(fn {title, data} ->
|
|
@tag data: data
|
|
test title, %{data: data} do
|
|
assert JSON.LD.expand(data.input) == data.output
|
|
end
|
|
end)
|
|
end
|
|
|
|
describe "errors" do
|
|
%{
|
|
"non-null @value and null @type" => %{
|
|
input: %{"http://example.com/foo" => %{"@value" => "foo", "@type" => nil}},
|
|
exception: JSON.LD.InvalidTypeValueError
|
|
},
|
|
"non-null @value and null @language" => %{
|
|
input: %{"http://example.com/foo" => %{"@value" => "foo", "@language" => nil}},
|
|
exception: JSON.LD.InvalidLanguageTaggedStringError
|
|
},
|
|
"value with null language" => %{
|
|
input: %{
|
|
"@context" => %{"@language" => "en"},
|
|
"http://example.org/nolang" => %{"@value" => "no language", "@language" => nil}
|
|
},
|
|
exception: JSON.LD.InvalidLanguageTaggedStringError
|
|
},
|
|
"@list containing @list" => %{
|
|
input: %{
|
|
"http://example.com/foo" => %{"@list" => [%{"@list" => ["baz"]}]}
|
|
},
|
|
exception: JSON.LD.ListOfListsError
|
|
},
|
|
"@list containing @list (with coercion)" => %{
|
|
input: %{
|
|
"@context" => %{"foo" => %{"@id" => "http://example.com/foo", "@container" => "@list"}},
|
|
"foo" => [%{"@list" => ["baz"]}]
|
|
},
|
|
exception: JSON.LD.ListOfListsError
|
|
},
|
|
"coerced @list containing an array" => %{
|
|
input: %{
|
|
"@context" => %{"foo" => %{"@id" => "http://example.com/foo", "@container" => "@list"}},
|
|
"foo" => [["baz"]]
|
|
},
|
|
exception: JSON.LD.ListOfListsError
|
|
},
|
|
"@reverse object with an @id property" => %{
|
|
input: Jason.decode!(~s({
|
|
"@id": "http://example/foo",
|
|
"@reverse": {
|
|
"@id": "http://example/bar"
|
|
}
|
|
})),
|
|
exception: JSON.LD.InvalidReversePropertyMapError
|
|
},
|
|
"colliding keywords" => %{
|
|
input: Jason.decode!(~s({
|
|
"@context": {
|
|
"id": "@id",
|
|
"ID": "@id"
|
|
},
|
|
"id": "http://example/foo",
|
|
"ID": "http://example/bar"
|
|
})),
|
|
exception: JSON.LD.CollidingKeywordsError
|
|
}
|
|
}
|
|
|> Enum.each(fn {title, data} ->
|
|
@tag data: data
|
|
test title, %{data: data} do
|
|
assert_raise data.exception, fn -> JSON.LD.expand(data.input) end
|
|
end
|
|
end)
|
|
end
|
|
|
|
describe "expand_value" do
|
|
setup do
|
|
context =
|
|
JSON.LD.context(%{
|
|
# TODO: RDF::Vocab::DC.to_uri.to_s,
|
|
"dc" => "http://purl.org/dc/terms/",
|
|
"ex" => "http://example.org/",
|
|
# TODO: RDF::Vocab::FOAF.to_uri.to_s,
|
|
"foaf" => "http://xmlns.com/foaf/0.1/",
|
|
"xsd" => "http://www.w3.org/2001/XMLSchema#",
|
|
"foaf:age" => %{"@type" => "xsd:integer"},
|
|
"foaf:knows" => %{"@type" => "@id"},
|
|
"dc:created" => %{"@type" => "xsd:date"},
|
|
"ex:integer" => %{"@type" => "xsd:integer"},
|
|
"ex:double" => %{"@type" => "xsd:double"},
|
|
"ex:boolean" => %{"@type" => "xsd:boolean"}
|
|
})
|
|
|
|
%{example_context: context}
|
|
end
|
|
|
|
~w(boolean integer string dateTime date time)
|
|
|> Enum.each(fn dt ->
|
|
@tag skip:
|
|
"This seems to be RDF.rb specific. The @id keys are produced when value is an RDF::URI or RDF::Node. Do we need/want something similar?"
|
|
@tag dt: dt
|
|
test "expands datatype xsd:#{dt}", %{dt: dt, example_context: context} do
|
|
assert expand_value(context, "foo", apply(XSD, String.to_atom(dt), []) |> to_string) ==
|
|
%{"@id" => "http://www.w3.org/2001/XMLSchema##{dt}"}
|
|
end
|
|
end)
|
|
|
|
%{
|
|
"absolute IRI" => ["foaf:knows", "http://example.com/", %{"@id" => "http://example.com/"}],
|
|
"term" => ["foaf:knows", "ex", %{"@id" => "ex"}],
|
|
"prefix:suffix" => ["foaf:knows", "ex:suffix", %{"@id" => "http://example.org/suffix"}],
|
|
"no IRI" => ["foo", "http://example.com/", %{"@value" => "http://example.com/"}],
|
|
"no term" => ["foo", "ex", %{"@value" => "ex"}],
|
|
"no prefix" => ["foo", "ex:suffix", %{"@value" => "ex:suffix"}],
|
|
"integer" => ["foaf:age", "54", %{"@value" => "54", "@type" => XSD.integer() |> to_string}],
|
|
"date " => [
|
|
"dc:created",
|
|
"2011-12-27Z",
|
|
%{"@value" => "2011-12-27Z", "@type" => XSD.date() |> to_string}
|
|
],
|
|
"native boolean" => ["foo", true, %{"@value" => true}],
|
|
"native integer" => ["foo", 1, %{"@value" => 1}],
|
|
"native double" => ["foo", 1.1e1, %{"@value" => 1.1e1}]
|
|
# TODO: Do we really want to support the following? RDF.rb has another implementation and uses this function
|
|
# for its implementation of fromRdf, instead of the RDF to Object Conversion algorithm in the spec ...
|
|
# "native date" => ["foo", ~D[2011-12-27], %{"@value" => "2011-12-27", "@type" => XSD.date |> to_string}],
|
|
# "native time" => ["foo", ~T[10:11:12Z], %{"@value" => "10:11:12Z", "@type" => XSD.time |> to_string}],
|
|
# "native dateTime" =>["foo", DateTime.from_iso8601("2011-12-27T10:11:12Z") |> elem(1), %{"@value" => "2011-12-27T10:11:12Z", "@type" => XSD.dateTime |> to_string}],
|
|
# "rdf boolean" => ["foo", RDF::Literal(true), %{"@value" => "true", "@type" => RDF::XSD.boolean.to_s}],
|
|
# "rdf integer" => ["foo", RDF::Literal(1), %{"@value" => "1", "@type" => XSD.integer |> to_string],
|
|
# "rdf decimal" => ["foo", RDF::Literal::Decimal.new(1.1), %{"@value" => "1.1", "@type" => XSD.decimal |> to_string}],
|
|
# "rdf double" => ["foo", RDF::Literal::Double.new(1.1), %{"@value" => "1.1E0", "@type" => XSD.double |> to_string}],
|
|
# "rdf URI" => ["foo", RDF::URI("foo"), %{"@id" => "foo"}],
|
|
# "rdf date " => ["foo", RDF::Literal(Date.parse("2011-12-27")), %{"@value" => "2011-12-27", "@type" => XSD.date |> to_string}],
|
|
# "rdf nonNeg" => ["foo", RDF::Literal::NonNegativeInteger.new(1), %{"@value" => "1", "@type" => XSD.nonNegativeInteger |> to_string}],
|
|
# "rdf float" => ["foo", RDF::Literal::Float.new(1.0), %{"@value" => "1.0", "@type" => XSD.float |> to_string}],
|
|
}
|
|
|> Enum.each(fn {title, data} ->
|
|
@tag data: data
|
|
test title, %{data: [key, compacted, expanded], example_context: context} do
|
|
assert expand_value(context, key, compacted) == expanded
|
|
end
|
|
end)
|
|
|
|
# context "@language" do
|
|
# before(:each) {subject.default_language = "en"}
|
|
%{
|
|
"no IRI" => [
|
|
"foo",
|
|
"http://example.com/",
|
|
%{"@value" => "http://example.com/", "@language" => "en"}
|
|
],
|
|
"no term" => ["foo", "ex", %{"@value" => "ex", "@language" => "en"}],
|
|
"no prefix" => ["foo", "ex:suffix", %{"@value" => "ex:suffix", "@language" => "en"}],
|
|
"native boolean" => ["foo", true, %{"@value" => true}],
|
|
"native integer" => ["foo", 1, %{"@value" => 1}],
|
|
"native double" => ["foo", 1.1, %{"@value" => 1.1}]
|
|
}
|
|
|> Enum.each(fn {title, data} ->
|
|
# TODO
|
|
# @tag skip: "Do these errors originate from the differing context setup?"
|
|
@tag skip:
|
|
"Why does this produce @language tags in RDF.rb, although no term definition of foo exists? Is this also RDF.rb specific?"
|
|
@tag data: data
|
|
test "@language #{title}", %{data: [key, compacted, expanded], example_context: context} do
|
|
assert expand_value(context, key, compacted) == expanded
|
|
end
|
|
end)
|
|
|
|
%{
|
|
"boolean-boolean" => [
|
|
"ex:boolean",
|
|
true,
|
|
%{"@value" => true, "@type" => XSD.boolean() |> to_string}
|
|
],
|
|
"boolean-integer" => [
|
|
"ex:integer",
|
|
true,
|
|
%{"@value" => true, "@type" => XSD.integer() |> to_string}
|
|
],
|
|
"boolean-double" => [
|
|
"ex:double",
|
|
true,
|
|
%{"@value" => true, "@type" => XSD.double() |> to_string}
|
|
],
|
|
"double-boolean" => [
|
|
"ex:boolean",
|
|
1.1,
|
|
%{"@value" => 1.1, "@type" => XSD.boolean() |> to_string}
|
|
],
|
|
"double-double" => [
|
|
"ex:double",
|
|
1.1,
|
|
%{"@value" => 1.1, "@type" => XSD.double() |> to_string}
|
|
],
|
|
"double-integer" => [
|
|
"foaf:age",
|
|
1.1,
|
|
%{"@value" => 1.1, "@type" => XSD.integer() |> to_string}
|
|
],
|
|
"integer-boolean" => [
|
|
"ex:boolean",
|
|
1,
|
|
%{"@value" => 1, "@type" => XSD.boolean() |> to_string}
|
|
],
|
|
"integer-double" => ["ex:double", 1, %{"@value" => 1, "@type" => XSD.double() |> to_string}],
|
|
"integer-integer" => [
|
|
"foaf:age",
|
|
1,
|
|
%{"@value" => 1, "@type" => XSD.integer() |> to_string}
|
|
],
|
|
"string-boolean" => [
|
|
"ex:boolean",
|
|
"foo",
|
|
%{"@value" => "foo", "@type" => XSD.boolean() |> to_string}
|
|
],
|
|
"string-double" => [
|
|
"ex:double",
|
|
"foo",
|
|
%{"@value" => "foo", "@type" => XSD.double() |> to_string}
|
|
],
|
|
"string-integer" => [
|
|
"foaf:age",
|
|
"foo",
|
|
%{"@value" => "foo", "@type" => XSD.integer() |> to_string}
|
|
]
|
|
}
|
|
|> Enum.each(fn {title, data} ->
|
|
@tag data: data
|
|
test "coercion #{title}", %{data: [key, compacted, expanded], example_context: context} do
|
|
assert expand_value(context, key, compacted) == expanded
|
|
end
|
|
end)
|
|
end
|
|
end
|