de3ca9b1dae3a8dffda3dec6d69d62a58ee3622e

Committed 10 Apr 2025 03:31PM UTC coverage: 91.542%. Remained the same

Build # de3ca9b1dae3a8dffda3dec6d69d62a58ee3622e

Build Type

push

github

Committed by

marcelotto

Commit Message

Remove unused HTML versions of test manifests

Run Details

1775 of 1939 relevant lines covered (91.54%)

4387.12 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

72.73

/test/support/test_suite.ex

defmodule JSON.LD.TestSuite do
  @moduledoc """
  General helper functions for the W3C test suites.
  """

  defmodule NS do
    @moduledoc false
    use RDF.Vocabulary.Namespace

    defvocab MF,
      base_iri: "http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#",
      terms: [],
      strict: false

    defvocab JLD,
      base_iri: "https://w3c.github.io/json-ld-api/tests/vocab#",
      file: Path.absname("test/data/json-ld-api-tests/vocab.ttl"),
      strict: false
  end

  @compile {:no_warn_undefined, JSON.LD.TestSuite.NS.MF}
  @compile {:no_warn_undefined, JSON.LD.TestSuite.NS.JLD}

  @run_mode Application.compile_env(:json_ld, :w3c_test_suite_run_mode, :local)
  def run_mode, do: @run_mode

  case @run_mode do
    :local ->
      @path JSON.LD.TestData.file("json-ld-api-tests")

      def parse_json_file!(file) do
        case File.read(file(file)) do
          {:ok, content} -> Jason.decode!(content)
          {:error, reason} -> raise File.Error, path: file, action: "read", reason: reason
        end
      end

      def parse_nquads(file) do
        file
        |> file()
        |> RDF.NQuads.read_file!()
      end

    :remote ->
      @path "https://w3c.github.io/json-ld-api/tests/"
      def parse_json_file!(file) do
        file
        |> file()
        |> JSON.LD.DocumentLoader.RemoteDocument.load!()
        |> Map.get(:document)
      end

      def parse_nquads(file) do
        url = file(file)

        case Tesla.get(url) do
          {:ok, %Tesla.Env{status: status} = response} when status in 200..299 ->
            RDF.NQuads.read_string!(response.body)

          {:ok, %{status: status}} ->
            raise "HTTP request of #{url} failed with status #{status}"

          {:error, error} ->
            raise error
        end
      end

    invalid ->
      raise "Invalid W3C test suite run mode: #{inspect(invalid)}; allowed are local and remote"
  end

  defdelegate j(file), to: __MODULE__, as: :parse_json_file!

  def file({type, name}), do: file(type, name)
  def file(name), do: Path.join(@path, name)
  def file(type, name), do: Path.join([@path, to_string(type), name])

  def manifest_file(type), do: "#{type}-manifest.jsonld"

  def manifest(type) do
    type
    |> manifest_file()
    |> parse_json_file!()
  end

  def base_iri(%{"baseIri" => base_iri}), do: base_iri

  def expanded_base_iri(%{"baseIri" => base_iri}) do
    base_iri
  end

  def test_cases(type) when is_binary(type), do: type |> manifest() |> test_cases()
  def test_cases(manifest), do: manifest["sequence"]

  def test_cases_by_type(test_cases) do
    Enum.group_by(test_cases, fn %{"@type" => type} ->
      cond do
        "jld:PositiveEvaluationTest" in type -> :positive_evaluation_test
        "jld:NegativeEvaluationTest" in type -> :negative_evaluation_test
        "jld:PositiveSyntaxTest" in type -> :positive_syntax_test
        "jld:NegativeSyntaxTest" in type -> :negative_syntax_test
      end
    end)
  end

  def test_case_options(test_case) do
    test_case
    |> Map.get("option", %{})
    |> Enum.map(fn {key, value} ->
      {key |> Macro.underscore() |> String.to_atom(), value}
    end)
    |> Enum.map(fn
      {:expand_context, file} -> {:expand_context, j(file)}
      option -> option
    end)
  end

  def test_case_options(test_case, %{"baseIri" => base_iri}),
    do: test_case_options(test_case, base_iri)

  def test_case_options(test_case, base_iri) do
    test_case
    |> test_case_options()
    |> Keyword.put_new(:base, base_iri <> test_case["input"])
  end

  def skip_map(skipped, mode \\ nil) do
    Enum.flat_map(skipped, fn
      {tests, message} -> Enum.map(tests, &{&1, message})
      {^mode, tests, message} -> Enum.map(tests, &{&1, message})
      {_mode, _tests, _message} -> []
    end)
    |> Map.new()
  end

  defmacro skip_test(id, skipped) do
    quote do
      case unquote(skipped)[unquote(id)] do
        %{message: message} = options ->
          if earl_result = options[:earl_result] do
            @tag earl_result: earl_result
          end

          if earl_mode = options[:earl_mode] do
            @tag earl_mode: earl_mode
          end

          @tag skip: message

        message when is_binary(message) ->
          @tag skip: message

        _ ->
          nil
      end
    end
  end

  defmacro skip_json_ld_1_0_test(test_case) do
    quote do
      if get_in(unquote(test_case), ["option", "specVersion"]) == "json-ld-1.0" do
        @tag skip: "JSON-LD 1.0 test"
        @tag earl_result: :untested
      end
    end
  end
end

1	defmodule JSON.LD.TestSuite do
2	@moduledoc """
3	General helper functions for the W3C test suites.
4	"""
5
6	defmodule NS do
7	@moduledoc false
8	use RDF.Vocabulary.Namespace
9
10	defvocab MF,	×
11	base_iri: "http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#",
12	terms: [],
13	strict: false
14
15	defvocab JLD,	×
16	base_iri: "https://w3c.github.io/json-ld-api/tests/vocab#",
17	file: Path.absname("test/data/json-ld-api-tests/vocab.ttl"),
18	strict: false
19	end
20
21	@compile {:no_warn_undefined, JSON.LD.TestSuite.NS.MF}
22	@compile {:no_warn_undefined, JSON.LD.TestSuite.NS.JLD}
23
24	@run_mode Application.compile_env(:json_ld, :w3c_test_suite_run_mode, :local)
25	def run_mode, do: @run_mode	8✔
26
27	case @run_mode do
28	:local ->
29	@path JSON.LD.TestData.file("json-ld-api-tests")
30
31	def parse_json_file!(file) do
32	case File.read(file(file)) do	11,556✔
33	{:ok, content} -> Jason.decode!(content)	11,556✔
34	{:error, reason} -> raise File.Error, path: file, action: "read", reason: reason	×
35	end
36	end
37
38	def parse_nquads(file) do
39	file
40	\|> file()
41	\|> RDF.NQuads.read_file!()	1,684✔
42	end
43
44	:remote ->
45	@path "https://w3c.github.io/json-ld-api/tests/"
46	def parse_json_file!(file) do
47	file
48	\|> file()
49	\|> JSON.LD.DocumentLoader.RemoteDocument.load!()
50	\|> Map.get(:document)
51	end
52
53	def parse_nquads(file) do
54	url = file(file)
55
56	case Tesla.get(url) do
57	{:ok, %Tesla.Env{status: status} = response} when status in 200..299 ->
58	RDF.NQuads.read_string!(response.body)
59
60	{:ok, %{status: status}} ->
61	raise "HTTP request of #{url} failed with status #{status}"
62
63	{:error, error} ->
64	raise error
65	end
66	end
67
68	invalid ->
69	raise "Invalid W3C test suite run mode: #{inspect(invalid)}; allowed are local and remote"
70	end
71
72	defdelegate j(file), to: __MODULE__, as: :parse_json_file!	11,532✔
73
74	def file({type, name}), do: file(type, name)	×
75	def file(name), do: Path.join(@path, name)	15,108✔
76	def file(type, name), do: Path.join([@path, to_string(type), name])	×
77
78	def manifest_file(type), do: "#{type}-manifest.jsonld"	24✔
79
80	def manifest(type) do
81	type
82	\|> manifest_file()
83	\|> parse_json_file!()	24✔
84	end
85
86	def base_iri(%{"baseIri" => base_iri}), do: base_iri	×
87
88	def expanded_base_iri(%{"baseIri" => base_iri}) do
89	base_iri	24✔
90	end
91
92	def test_cases(type) when is_binary(type), do: type \|> manifest() \|> test_cases()	×
93	def test_cases(manifest), do: manifest["sequence"]	24✔
94
95	def test_cases_by_type(test_cases) do
96	Enum.group_by(test_cases, fn %{"@type" => type} ->	24✔
97	cond do	4,908✔
98	"jld:PositiveEvaluationTest" in type -> :positive_evaluation_test	3,892✔
99	"jld:NegativeEvaluationTest" in type -> :negative_evaluation_test	1,016✔
100	"jld:PositiveSyntaxTest" in type -> :positive_syntax_test	64✔
101	"jld:NegativeSyntaxTest" in type -> :negative_syntax_test	×
102	end
103	end)
104	end
105
106	def test_case_options(test_case) do
107	test_case
108	\|> Map.get("option", %{})
109	\|> Enum.map(fn {key, value} ->	4,904✔
110	{key \|> Macro.underscore() \|> String.to_atom(), value}
111	end)
112	\|> Enum.map(fn	7,068✔
113	{:expand_context, file} -> {:expand_context, j(file)}	12✔
114	option -> option	4,892✔
115	end)
116	end
117
118	def test_case_options(test_case, %{"baseIri" => base_iri}),
119	do: test_case_options(test_case, base_iri)	×
120
121	def test_case_options(test_case, base_iri) do
122	test_case
123	\|> test_case_options()
124	\|> Keyword.put_new(:base, base_iri <> test_case["input"])	7,012✔
125	end
126
127	def skip_map(skipped, mode \\ nil) do
128	Enum.flat_map(skipped, fn
129	{tests, message} -> Enum.map(tests, &{&1, message})	16✔
130	{^mode, tests, message} -> Enum.map(tests, &{&1, message})	8✔
131	{_mode, _tests, _message} -> []	8✔
132	end)
133	\|> Map.new()	20✔
134	end
135
136	defmacro skip_test(id, skipped) do
137	quote do
138	case unquote(skipped)[unquote(id)] do
139	%{message: message} = options ->
140	if earl_result = options[:earl_result] do
141	@tag earl_result: earl_result
142	end
143
144	if earl_mode = options[:earl_mode] do
145	@tag earl_mode: earl_mode
146	end
147
148	@tag skip: message
149
150	message when is_binary(message) ->
151	@tag skip: message
152
153	_ ->
154	nil
155	end
156	end
157	end
158
159	defmacro skip_json_ld_1_0_test(test_case) do
160	quote do
161	if get_in(unquote(test_case), ["option", "specVersion"]) == "json-ld-1.0" do
162	@tag skip: "JSON-LD 1.0 test"
163	@tag earl_result: :untested
164	end
165	end
166	end
167	end

rdf-elixir / jsonld-ex / de3ca9b1dae3a8dffda3dec6d69d62a58ee3622e

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous