rdf-ex/test/unit/list_test.exs

defmodule RDF.ListTest do
  use RDF.Test.Case

  doctest RDF.List

  import RDF.Sigils

  alias RDF.{IRI, BlankNode, Literal, Graph}

  use RDF.Vocabulary.Namespace

  defvocab EX,
    base_iri: "http://example.org/#",
    terms: [], strict: false

  setup do
    {:ok,
      empty:  RDF.List.new(RDF.nil, Graph.new),
      one:    RDF.List.from([EX.element],           head: ~B<one>),
      abc:    RDF.List.from(~w[a b c],              head: ~B<abc>),
      ten:    RDF.List.from(Enum.to_list(1..10),    head: ~B<ten>),
      nested: RDF.List.from(["foo", [1, 2], "bar"], head: ~B<nested>),
    }
  end


  describe "new/2" do

    #######################################################################
    # success cases

    test "valid head list node" do
      graph = Graph.new(
                   ~B<Foo>
                   |> RDF.first(1)
                   |> RDF.rest(~B<Bar>))
               |> Graph.add(
                   ~B<Bar>
                   |> RDF.first(2)
                   |> RDF.rest(RDF.nil))
      assert %RDF.List{} = list = RDF.List.new(~B<Foo>, graph)
      assert list.head == ~B<Foo>
      assert list.graph == graph
    end

    test "with non-blank list nodes" do
      graph = Graph.new(
                   EX.Foo
                   |> RDF.first(1)
                   |> RDF.rest(RDF.nil))
      assert %RDF.List{} = list = RDF.List.new(EX.Foo, graph)
      assert list.head == iri(EX.Foo)
    end

    test "with other properties on its nodes" do
      assert RDF.List.new(~B<Foo>,
               Graph.new(
                   ~B<Foo>
                   |> EX.other(EX.Property)
                   |> RDF.first(1)
                   |> RDF.rest(~B<Bar>))
               |> Graph.add(
                   ~B<Bar>
                   |> EX.other(EX.Property2)
                   |> RDF.first(2)
                   |> RDF.rest(RDF.nil))
             )
             |> RDF.List.valid? == true
    end

    #######################################################################
    # failure cases

    test "when given list node doesn't exist in the given graph" do
      assert RDF.List.new(RDF.bnode, RDF.Graph.new) == nil
    end

    test "When the given head node is not a list" do
      assert RDF.List.new(42, RDF.Graph.new) == nil
      assert RDF.List.new(EX.Foo, RDF.Graph.new({EX.Foo, EX.bar, EX.Baz})) == nil
      assert RDF.List.new(EX.Foo, RDF.Graph.new({EX.Foo, RDF.first, EX.Baz})) == nil
    end


    test "when list nodes are incomplete" do
      assert RDF.List.new(EX.Foo, RDF.Graph.new({EX.Foo, RDF.first, EX.Baz})) == nil
      assert RDF.List.new(EX.Foo, RDF.Graph.new({EX.Foo, RDF.rest, RDF.nil})) == nil
    end

    test "when head node has multiple rdf:first objects" do
      assert RDF.List.new(~B<Foo>,
               Graph.new(
                   ~B<Foo>
                   |> RDF.first(1, 2)
                   |> RDF.rest(RDF.nil))
             ) == nil
    end

    test "when later list nodes have multiple rdf:first objects" do
      assert RDF.List.new(~B<Foo>,
               Graph.new(
                   ~B<Foo>
                   |> RDF.first(1)
                   |> RDF.rest(~B<Bar>))
               |> Graph.add(
                   ~B<Bar>
                   |> RDF.first(2, 3)
                   |> RDF.rest(RDF.nil))
             ) == nil
    end

    test "when list nodes have multiple rdf:rest objects" do
      assert RDF.List.new(~B<Foo>,
               Graph.new(
                   ~B<Foo>
                   |> RDF.first(1)
                   |> RDF.rest(~B<Bar>, ~B<Baz>))
               |> Graph.add(
                   ~B<Bar>
                   |> RDF.first(2)
                   |> RDF.rest(RDF.nil))
               |> Graph.add(
                   ~B<Baz>
                   |> RDF.first(3)
                   |> RDF.rest(RDF.nil))
             ) == nil
      assert RDF.List.new(~B<Foo>,
               Graph.new(
                   ~B<Foo>
                   |> RDF.first(1)
                   |> RDF.rest(~B<Bar>))
               |> Graph.add(
                   ~B<Bar>
                   |> RDF.first(2)
                   |> RDF.rest(RDF.nil, ~B<Baz>))
               |> Graph.add(
                   ~B<Baz>
                   |> RDF.first(3)
                   |> RDF.rest(RDF.nil))
             ) == nil
    end

    test "when the list is cyclic" do
      assert RDF.List.new(~B<Foo>,
               Graph.new(
                   ~B<Foo>
                   |> RDF.first(1)
                   |> RDF.rest(~B<Bar>))
               |> Graph.add(
                   ~B<Bar>
                   |> RDF.first(2)
                   |> RDF.rest(~B<Foo>))
             ) == nil
    end
  end


  describe "from/1" do
    test "an empty list", %{empty: empty} do
      assert RDF.List.from([]) == empty
    end

    test "an empty list with named head node", %{empty: empty} do
      assert RDF.List.from([], name: ~B<foo>) == empty
    end

    %{
      "IRI"        => iri(EX.Foo),
      "blank node" => ~B<Foo>,
      "literal"    => ~L<Foo>,
      "string"     => "Foo",
      "integer"    => 42,
      "float"      => 3.14,
      "true"       => true,
      "false"      => false,
      "unresolved namespace-qualified name" => EX.Foo,
    }
    |> Enum.each(fn {type, element} ->
        @tag element: element
        test "list with #{type} element", %{element: element} do
          with {bnode, graph_with_list} = one_element_list(element) do
            assert RDF.List.from([element], head: bnode) ==
                    RDF.List.new(bnode, graph_with_list)
          end
        end
       end)

    test "nested list" do
      assert %RDF.List{head: bnode, graph: graph_with_list} =
              RDF.List.from([[1]])
      assert [nested] = get_in(graph_with_list, [bnode, RDF.first])
      assert get_in(graph_with_list, [bnode, RDF.rest]) == [RDF.nil]
      assert get_in(graph_with_list, [nested, RDF.first]) == [XSD.integer(1)]
      assert get_in(graph_with_list, [nested, RDF.rest]) == [RDF.nil]

      assert %RDF.List{head: bnode, graph: graph_with_list} =
              RDF.List.from(["foo", [1, 2], "bar"])
      assert get_in(graph_with_list, [bnode, RDF.first]) == [~L"foo"]
      assert [second] = get_in(graph_with_list, [bnode, RDF.rest])
      assert [nested] = get_in(graph_with_list, [second, RDF.first])
      assert get_in(graph_with_list, [nested, RDF.first]) == [XSD.integer(1)]
      assert [nested_second] = get_in(graph_with_list, [nested, RDF.rest])
      assert get_in(graph_with_list, [nested_second, RDF.first]) == [XSD.integer(2)]
      assert get_in(graph_with_list, [nested_second, RDF.rest])  == [RDF.nil]
      assert [third] = get_in(graph_with_list, [second, RDF.rest])
      assert get_in(graph_with_list, [third, RDF.first]) == [~L"bar"]
      assert get_in(graph_with_list, [third, RDF.rest])  == [RDF.nil]
    end

    %{
      "preserve order"  => [3, 2, 1],
      "different types" => [1, "foo", true, false, 3.14, EX.foo, EX.Foo, ~B<Foo>],
    }
    |> Enum.each(fn {desc, list} ->
        @tag list: list
        test "list with multiple elements: #{desc}", %{list: list} do
          assert %RDF.List{head: bnode, graph: graph_with_list} =
                  RDF.List.from(list)
          assert RDF.nil ==
            Enum.reduce list, bnode, fn element, list_node ->
              case element do
                %IRI{} ->
                  assert get_in(graph_with_list, [list_node, RDF.first]) == [element]
                %BlankNode{} ->
                  assert get_in(graph_with_list, [list_node, RDF.first]) == [element]
                %Literal{} ->
                  assert get_in(graph_with_list, [list_node, RDF.first]) == [element]
                element when is_boolean(element) ->
                  assert get_in(graph_with_list, [list_node, RDF.first]) == [RDF.Literal.new(element)]
                element when is_atom(element) ->
                  assert get_in(graph_with_list, [list_node, RDF.first]) == [RDF.iri(element)]
                _ ->
                  assert get_in(graph_with_list, [list_node, RDF.first]) == [RDF.Literal.new(element)]
              end
              [next] = get_in(graph_with_list, [list_node, RDF.rest])
              unless next == RDF.nil do
                assert %BlankNode{} = next
              end
              next
            end
        end
       end)

    test "an enumerable" do
      assert RDF.List.from(MapSet.new([42]), head: ~B<foo>) ==
              RDF.List.from([42], head: ~B<foo>)
    end

    test "head option with unresolved namespace-qualified name" do
      assert RDF.List.from([42], head: EX.Foo).head == iri(EX.Foo)
    end
  end


  describe "values/1" do
    test "the empty list", %{empty: empty} do
      assert RDF.List.values(empty) == []
    end

    test "list with one element", %{one: one} do
      assert RDF.List.values(one) == [EX.element]
    end

    test "list with multiple elements", %{abc: abc, ten: ten} do
      assert RDF.List.values(abc) == ~w[a b c] |> Enum.map(&Literal.new/1)
      assert RDF.List.values(ten) == 1..10 |> Enum.to_list |> Enum.map(&Literal.new/1)
    end

    test "list with non-blank list nodes" do
      assert RDF.List.from([EX.element], head: EX.Foo)
             |> RDF.List.values == [EX.element]
    end

    test "nested list", %{nested: nested} do
      assert RDF.List.values(nested) ==
                [~L"foo", [XSD.integer(1), XSD.integer(2)], ~L"bar"]

      assert RDF.list(["foo", [1, 2]]) |> RDF.List.values ==
                [~L"foo", [XSD.integer(1), XSD.integer(2)]]

      assert RDF.list([[1, 2], "foo"]) |> RDF.List.values ==
                [[XSD.integer(1), XSD.integer(2)], ~L"foo"]

      inner_list = RDF.list([1, 2], head: ~B<inner>)
      assert RDF.list(["foo", ~B<inner>], graph: inner_list.graph)
             |> RDF.List.values == [~L"foo", [XSD.integer(1), XSD.integer(2)]]
    end
  end


  describe "nodes/1" do
    test "the empty list", %{empty: empty} do
      assert RDF.List.nodes(empty) == []
    end

    test "non-empty list", %{one: one} do
      assert RDF.List.nodes(one) == [~B<one>]
    end

    test "nested list", %{nested: nested} do
      assert RDF.list([[1, 2, 3]], head: ~B<outer>)
             |> RDF.List.nodes == [~B<outer>]
      assert [~B<nested>, _, _] = RDF.List.nodes(nested)
    end
  end


  describe "valid?/2" do
    test "the empty list", %{empty: empty} do
      assert RDF.List.valid?(empty)
    end

    test "valid list with one element", %{one: one} do
      assert RDF.List.valid?(one) == true
    end

    test "valid list with multiple elements", %{abc: abc, ten: ten} do
      assert RDF.List.valid?(abc) == true
      assert RDF.List.valid?(ten) == true
    end

    test "valid nested list", %{nested: nested} do
      assert RDF.List.valid?(nested) == true
    end

    test "a non-blank list node is not valid" do
      assert RDF.list([EX.element], head: EX.Foo) |> RDF.List.valid? == false
    end

    test "a non-blank list node on later nodes makes the whole list invalid" do
      assert RDF.List.new(~B<Foo>,
               Graph.new(
                   ~B<Foo>
                   |> RDF.first(1)
                   |> RDF.rest(EX.Foo))
               |> Graph.add(
                   EX.Foo
                   |> RDF.first(2)
                   |> RDF.rest(RDF.nil))
             )
             |> RDF.List.valid? == false
    end
  end


  describe "node?" do
    test "the empty list", %{empty: empty} do
      assert RDF.List.node?(empty.head, empty.graph) == true
    end

    test "list with one element", %{one: one} do
      assert RDF.List.node?(one.head, one.graph) == true
    end

    test "list with multiple elements", %{abc: abc, ten: ten} do
      assert RDF.List.node?(abc.head, abc.graph) == true
      assert RDF.List.node?(ten.head, ten.graph) == true
    end

    test "nested list", %{nested: nested} do
      assert RDF.List.node?(nested.head, nested.graph) == true
    end

    test "unresolved namespace-qualified name" do
      assert RDF.List.node?(EX.Foo,
              RDF.List.from([EX.element], head: EX.Foo).graph) == true
    end

    test "when given list node doesn't exist in the given graph" do
      assert RDF.List.node?(RDF.bnode, RDF.Graph.new) == false
    end

    test "literal" do
      assert RDF.List.node?(~L"Foo", RDF.Graph.new) == false
      assert RDF.List.node?(42, RDF.Graph.new) == false
      assert RDF.List.node?(true, RDF.Graph.new) == false
      assert RDF.List.node?(false, RDF.Graph.new) == false
      assert RDF.List.node?(nil, RDF.Graph.new) == false
    end

    test "non-list node" do
      assert RDF.List.node?(EX.Foo, RDF.Graph.new({EX.Foo, EX.bar, EX.Baz})) == false
    end

    test "incomplete list nodes" do
      assert RDF.List.node?(EX.Foo, RDF.Graph.new({EX.Foo, RDF.first, EX.Baz})) == false
      assert RDF.List.node?(EX.Foo, RDF.Graph.new({EX.Foo, RDF.rest, RDF.nil})) == false
    end
  end


  describe "Enumerable.reduce" do
    test "the empty list", %{empty: empty} do
      assert Enum.reduce(empty, [], fn description, acc -> [description | acc] end) == []
    end

    test "a valid list", %{one: one} do
      assert [one.graph[one.head]] ==
        Enum.reduce(one, [], fn description, acc -> [description | acc] end)
    end

  end


  defp one_element_list(element),
    do: one_element_list(element, RDF.bnode)

  defp one_element_list(element, bnode) do
    {bnode,
      Graph.new(
        bnode
        |> RDF.first(element)
        |> RDF.rest(RDF.nil)
      )
    }
  end

end