added tests and fixed small bug and fixed typos

Author: Michael Fritzsche

src/hermes/model/types/ld_container.py

@@ -224,7 +224,7 @@ def _to_expanded_json(
         :param value: The value that is to be expanded. Different types are expected based on the type of self:
             <ul><li>If type(self) == ld_dict: value must be a dict</li>
             <li>If type(self) == ld_list: value must be a list</li></ul>
-            value will be exapnded as if it was the data_dict/ the item_list of self.
+            value will be expanded as if it was the data_dict/ the item_list of self.
         :type value: JSON_LD_VALUE
 
         :return: The expanded version of value i.e. the data_dict/ item_list of self if it had been value.
@@ -293,14 +293,8 @@ def _to_expanded_json(
         for index in range(len(path) - 1, 0, -1):
             current_data = current_data[path[index]]
         # replace the data_dict/ item_list so that value is now inside of the ld_value of parent and store the old value
-        if current_data == []:
-            # itemlist of an empty ld_list:
-            # The item_list can't be replaced like in all other cases
-            self_data = None
-            current_data.append(value)
-        else:
-            self_data = current_data[path[0]]
-            current_data[path[0]] = value
+        self_data = current_data[path[0]]
+        current_data[path[0]] = value
 
         # expand the ld_value of parent to implicitly expand value
         # important the ld_value of parent is not modified because the processor makes a deep copy
@@ -310,10 +304,7 @@ def _to_expanded_json(
         )
 
         # restore the data_dict/ item_list to its former state
-        if self_data is not None:
-            current_data[path[0]] = self_data
-        else:
-            current_data.clear()
+        current_data[path[0]] = self_data
 
         # use the path to get the expansion of value
         for index in range(len(path) - 1, -1, -1):

src/hermes/model/types/ld_list.py

@@ -59,8 +59,12 @@ def __init__(
         :return:
         :rtype: None
 
-        :raises ValueError: bla
-        :raises ValueError: bla
+        :raises ValueError: If the given key is not a string or None was given.
+        :raises ValueError: If the given data is not a list.
+        :raises ValueError: If the data represents an unexpanded @set. I.e. is of the form [{"@set": [...]}]
+        :raises ValueError: If the given key is "@type" but the container_type not "@set"
+            or a value in the item_list not a string.
+        :raises ValueError: If the given key is not "@type" and any value in the item_list not a dict.
         """
         # check for validity of data
         if not isinstance(key, str):
@@ -272,8 +276,16 @@ def __eq__(
             other = [other]
         if isinstance(other, list):
             if ld_list.is_ld_list(other):
-                other = ld_list.get_item_list_from_container(other[0])
-            other = self.from_list(other, parent=self.parent, key=self.key, context=self.context)
+                if "@list" in other[0]:
+                    cont = "@list"
+                elif "@graph" in other[0]:
+                    cont = "@graph"
+                else:
+                    cont = "@set"
+                other = other[0][cont]
+            else:
+                cont = "@set"
+            other = self.from_list(other, parent=self.parent, key=self.key, context=self.context, container_type=cont)
 
         # check if the length matches
         if len(self.item_list) != len(other.item_list):
@@ -338,7 +350,7 @@ def __eq__(
                         # swap order if first try returned NotImplemented
                         res = other_item.__eq__(item)
                     # if one of both comparisons returned true the elements are equal
-                    if res:
+                    if res is not NotImplemented and res:
                         equality_pairs[index] += [other_index]
                 if len(equality_pairs[index]) == 0:
                     # there exists no element in other that is equal to item
@@ -624,7 +636,7 @@ def from_list(
         :type value: list[JSON_LD_VALUE | BASIC_TYPE | TIME_TYPE]
         :param parent: The parent container of the new ld_list.<br>If value is assimilated by parent druing JSON-LD
             expansion parent is extended by value and parent is returned.
-        :type parent: ls_container | None
+        :type parent: ld_container | None
         :param key: The key into the inner most parent container representing a dict of the new ld_list.
         :type: key: str | None
         :param context: The context for the new list (is will also inherit the context of parent).<br>

test/hermes_test/model/types/test_ld_container.py

@@ -6,7 +6,7 @@
 # SPDX-FileContributor: Michael Meinel
 # SPDX-FileContributor: Michael Fritzsche
 
-from datetime import datetime
+from datetime import datetime, time
 
 import pytest
 
@@ -121,6 +121,11 @@ def test_to_python_datetime_value(self, mock_context):
             "@value": "2022-02-22T00:00:00", "@type": "https://schema.org/DateTime"
         }) == "2022-02-22T00:00:00"  # TODO: #434 typed date is returned as string instead of date
 
+    def test_to_python_error(self, mock_context):
+        cont = ld_container([{}], context=[mock_context])
+        with pytest.raises(TypeError):
+            cont._to_python("http://spam.eggs/eggs", set())
+
     def test_to_expanded_id(self, mock_context):
         cont = ld_dict([{}], context=[mock_context])
         assert cont._to_expanded_json({"@id": f"{self.url}identifier"}) == {"@id": f"{self.url}identifier"}
@@ -156,6 +161,35 @@ def test_to_expanded_datetime_value(self, mock_context):
         assert cont._to_expanded_json({"eggs": datetime(2022, 2, 22)}) == {"http://spam.eggs/eggs": [{"@list": [
             {"@value": "2022-02-22T00:00:00", "@type": "https://schema.org/DateTime"}
         ]}]}
+        cont = ld_dict([{}], context=[mock_context])
+        assert cont._to_expanded_json({"eggs": time(5, 4, 3)}) == {"http://spam.eggs/eggs": [{"@list": [
+            {"@value": "05:04:03", "@type": "https://schema.org/Time"}
+        ]}]}
+
+    def test_compact(self, mock_context):
+        cont = ld_container([{"http://spam.eggs/eggs": [{"@list": [{"@value": "a"}]}],
+                              "http://spam.eggs/spam": [{"@value": "bacon"}]}])
+        assert cont.compact([mock_context]) == {"@context": mock_context, "spam": "bacon", "eggs": ["a"]}
+
+    def test_is_ld_id(self):
+        assert ld_container.is_ld_id([{"@id": "foo"}])
+        assert not ld_container.is_ld_id([{"@id": "foo", "bar": "barfoo"}])
+        assert not ld_container.is_ld_id({"@id": "foo"})
+        assert not ld_container.is_ld_id([{"bar": "foo"}])
+
+    def test_is_ld_value(self):
+        assert ld_container.is_ld_value([{"@value": "foo"}])
+        assert ld_container.is_ld_value([{"@value": "foo", "bar": "barfoo"}])
+        assert not ld_container.is_ld_value({"@value": "foo"})
+        assert not ld_container.is_ld_value([{"bar": "foo"}])
+
+    def test_is_typed_ld_value(self):
+        assert ld_container.is_typed_ld_value([{"@value": "foo", "@type": "bar"}])
+        assert ld_container.is_typed_ld_value([{"@value": "foo", "@type": "bar", "bar": "barfoo"}])
+        assert not ld_container.is_typed_ld_value([{"@type": "bar"}])
+        assert not ld_container.is_typed_ld_value([{"@value": "foo"}])
+        assert not ld_container.is_typed_ld_value({"@value": "foo", "@type": "bar"})
+        assert not ld_container.is_typed_ld_value([{"bar": "foo"}])
 
     def test_are_values_equal(self):
         assert ld_container.are_values_equal({"@id": "foo"}, {"@id": "foo"})

test/hermes_test/model/types/test_ld_list.py

@@ -14,24 +14,31 @@
 
 def test_undefined_list():
     with pytest.raises(ValueError):
-        ld_list([{}])
+        ld_list({}, key="foo")
     with pytest.raises(ValueError):
-        ld_list([{"spam": [{"@value": "bacon"}]}])
+        ld_list([{"@set": [{"@value": "bacon"}]}], key="foo")
     with pytest.raises(ValueError):
-        ld_list([{"@list": [0], "spam": [{"@value": "bacon"}]}])
+        ld_list([{"@value": "bacon"}], key="@type")
     with pytest.raises(ValueError):
-        ld_list([{"@list": ["a", "b"], "@set": ["foo", "bar"]}])
+        ld_list(["bacon"], key="eggs")
     with pytest.raises(ValueError):
         ld_list([{"@list": ["a", "b"]}])  # no given key
-    with pytest.raises(ValueError):
-        ld_list([{"@list": ["a", "b"]}, {"@set": ["foo", "bar"]}])
 
 
 def test_list_basics():
     li_data = [{"@list": [{"@value": "bar"}]}]
     li = ld_list(li_data, key="foo")
     assert li._data is li_data
     assert li.item_list is li_data[0]["@list"]
+    li_data = [{"@graph": [{"@value": "bar"}]}]
+    li = ld_list(li_data, key="foo")
+    assert li._data is li_data
+    assert li.item_list is li_data[0]["@graph"]
+    li_data = [{"@value": "bar"}]
+    li = ld_list(li_data, key="foo")
+    assert li._data is li_data
+    assert li.item_list is li_data
+    assert li.container_type == "@set"
 
 
 def test_build_in_get():
@@ -135,6 +142,12 @@ def test_build_in_iter():
 
 
 def test_append():
+    li = ld_list([{"@list": []}], key="https://schema.org/name", context=[{"schema": "https://schema.org/"}])
+    li.append(ld_list([{"@value": "foo"}], key="https://schema.org/name"))
+    assert isinstance(li[0], ld_list) and li[0].container_type == "@list"
+    li = ld_list([{"@graph": []}], key="https://schema.org/name", context=[{"schema": "https://schema.org/"}])
+    li.append({"schema:name": "foo"})
+    assert li[0] == {"https://schema.org/name": "foo"} and len(li) == 1
     li = ld_list([{"@list": []}], key="https://schema.org/name", context=[{"schema": "https://schema.org/"}])
     li.append("foo")
     assert li[0] == "foo" and li.item_list[0] == {"@value": "foo"} and len(li) == 1
@@ -153,6 +166,7 @@ def test_append():
 
 def test_build_in_contains():
     li = ld_list([], key="https://schema.org/name", context=[{"schema": "https://schema.org/"}])
+    assert [] in li
     li.append("foo")
     li.append({"@type": "A", "schema:name": "a"})
     assert "foo" in li and {"@type": "A", "schema:name": "a"} in li
@@ -162,9 +176,18 @@ def test_build_in_contains():
     li.append({"@id": "schema:foo", "schema:name": "foo"})
     assert {"@id": "schema:foo"} in li and {"@id": "schema:foo", "schema:name": "foobar"} in li
     assert {"schema:name": "foo"} in li
+    li = ld_list([{"@list": []}], key="https://schema.org/name", context=[{"schema": "https://schema.org/"}])
+    li.append("foo")
+    assert "foo" in li
 
 
 def test_build_in_comparison():
+    li = ld_list([{"@list": []}], key="https://schema.org/name", context=[{"schema": "https://schema.org/"}])
+    li.append({"@id": "foo", "schema:bar": "foobar"})
+    assert [{"@list": [{"@id": "foo", "schema:bar": "barfoo"}]}] == li
+    assert [{"@list": [{"@id": "bar", "schema:bar": "foobar"}]}] != li
+    assert [{"@set": [{"@id": "foo", "schema:bar": "barfoo"}]}] == li
+    assert [{"@graph": [{"@id": "foo", "schema:bar": "barfoo"}]}] == li
     li = ld_list([{"@list": []}], key="https://schema.org/name", context=[{"schema": "https://schema.org/"}])
     li2 = ld_list([{"@list": []}], key="https://schema.org/name", context=[{"schema2": "https://schema.org/"}])
     assert li == [] and [] == li
@@ -269,6 +292,10 @@ def test_is_container():
 
 
 def test_from_list():
+    with pytest.raises(ValueError):
+        ld_list.from_list([], key="@type", container_type="@list")
+    with pytest.raises(ValueError):
+        ld_list.from_list([], container_type="foo")
     li = ld_list.from_list([], key="schema:foo")
     assert li.item_list == li.context == [] and li.parent is li.index is None and li.key == "schema:foo"
     assert li._data == [] and li.container_type == "@set"
@@ -290,3 +317,9 @@ def test_get_item_list_from_container():
     assert ld_list.get_item_list_from_container({"@graph": ["a"]}) == ["a"]
     with pytest.raises(ValueError):
         ld_list.get_item_list_from_container(["a"])
+    with pytest.raises(ValueError):
+        ld_list.get_item_list_from_container({"@list": [], "@set": []})
+    with pytest.raises(ValueError):
+        ld_list.get_item_list_from_container({"@list": {}})
+    with pytest.raises(ValueError):
+        ld_list.get_item_list_from_container({"foo": []})