Fix collecting values for enumeration

Author: Hanna-Shalamitskaya-EPAM

.github/workflows/push_request_check.yml

@@ -37,7 +37,7 @@ jobs:
           poetry run download-samm-release
           poetry build
 
-      - name: run test*s
+      - name: run tests
         run: |
           cd core/esmf-aspect-meta-model-python
           poetry run tox -e py310

core/esmf-aspect-meta-model-python/esmf_aspect_meta_model_python/impl/__init__.py

@@ -45,3 +45,4 @@
 from .default_property import DefaultBlankProperty, DefaultProperty, DefaultPropertyWithExtends
 from .default_quantity_kind import DefaultQuantityKind
 from .default_unit import DefaultUnit
+from .default_value import DefaultValue

core/esmf-aspect-meta-model-python/esmf_aspect_meta_model_python/loader/instantiator/enumeration_instantiator.py

@@ -49,8 +49,8 @@ def __to_enum_node_value(self, value_node: Node) -> Union[Dict, str]:
         - If value_node is a URIRef it will represent a value of a ComplexType
         :return: the one generated value of the enumeration
         """
-        str_value: str = ""
-        dict_value: Dict = {}
+        str_value: Optional[str] = None
+        dict_value: Optional[Dict] = None
 
         if isinstance(value_node, rdflib.Literal) or (
             isinstance(value_node, rdflib.URIRef) and value_node.find("#") == -1
@@ -88,7 +88,7 @@ def __to_enum_node_value(self, value_node: Node) -> Union[Dict, str]:
                 f"a URI reference to a ComplexType. Values of type {type(value_node).__name__} are not allowed"
             )
 
-        return str_value or dict_value
+        return str_value if str_value is not None else dict_value if dict_value is not None else ""
 
     def __is_collection_value(self, property_subject: str) -> bool:
         characteristic = self._aspect_graph.value(  # type: ignore

core/esmf-aspect-meta-model-python/esmf_aspect_meta_model_python/loader/instantiator/state_instantiator.py

@@ -67,8 +67,10 @@ def __to_state_node_value(self, value_node: Optional[Node]) -> Dict:
                 if property_urn != rdflib.RDF.type and isinstance(property_urn, str):
                     property_name = property_urn.split("#")[1]
                     actual_value: Optional[Any]
-                    if self.__is_collection_value(property_urn):
-                        actual_value = self.__instantiate_enum_collection(property_value)
+                    if self._EnumerationInstantiator__is_collection_value(property_urn):  # type: ignore
+                        actual_value = self._EnumerationInstantiator__instantiate_enum_collection(  # type: ignore
+                            property_value
+                        )
                     else:
                         actual_value = self.__to_state_node_value(property_value)
                     value[property_name] = actual_value

core/esmf-aspect-meta-model-python/esmf_aspect_meta_model_python/loader/meta_model_base_attributes.py

@@ -94,10 +94,7 @@ def from_meta_model_element(
 
             return MetaModelBaseAttributes(meta_model_version, urn, name, preferred_names, descriptions, see)
 
-        raise TypeError(
-            "Unexpected type. Get MetaModelBaseAttributes.from_meta_model_element \
-            can't handle this type."
-        )
+        raise TypeError("Unexpected type. Get MetaModelBaseAttributes.from_meta_model_element can't handle this type.")
 
     @staticmethod
     def __create_default_name(meta_model_element: rdflib.BNode, aspect_graph, samm) -> str:
@@ -129,12 +126,14 @@ def __get_name_from_urn(urn: str) -> str:
             urn:samm:org.eclipse.esmf.examples:TestAspect:1.0.0 -> TestAspect
         """
         split_urn = urn.split("#")
+
         if len(split_urn) == 2:
-            # urn:samm:org.eclipse.esmf.examples#testProperty
-            return split_urn[1]
-        # urn:samm:org.eclipse.esmf.examples:TestAspect:1.0.0
-        split_urn = urn.split(":")
-        return split_urn[-2]
+            name = split_urn[1]
+        else:
+            split_urn = urn.split(":")
+            name = split_urn[-2]
+
+        return name
 
     @staticmethod
     def __get_language_strings(

core/esmf-aspect-meta-model-python/tests/unit/base/test_aspect.py

@@ -0,0 +1,59 @@
+"""Aspect interface test suite."""
+
+from esmf_aspect_meta_model_python.base.aspect import Aspect
+
+
+class AspectInterface(Aspect):
+    """Aspect interface class for testing."""
+
+    def __init__(self, name):
+        self._name = name
+
+    def urn(self):
+        pass
+
+    def meta_model_version(self):
+        pass
+
+    @property
+    def name(self):
+        return self._name
+
+    def preferred_names(self):
+        pass
+
+    def descriptions(self):
+        pass
+
+    def see(self):
+        pass
+
+    def events(self):
+        pass
+
+    def operations(self):
+        pass
+
+    def properties(self):
+        pass
+
+    @property
+    def parent_elements(self):
+        return None
+
+    @parent_elements.setter
+    def parent_elements(self, elements):
+        pass
+
+    def append_parent_element(self, element):
+        pass
+
+
+class TestAspect:
+    """Aspect interface test suite."""
+
+    def test_is_collection_aspect(self):
+        aspect = AspectInterface("name")
+        result = aspect.is_collection_aspect
+
+        assert result is False

core/esmf-aspect-meta-model-python/tests/unit/base/test_property.py

@@ -0,0 +1,90 @@
+"""Property interface test suite."""
+
+from unittest import mock
+
+from esmf_aspect_meta_model_python.base.characteristics.trait import Trait
+from esmf_aspect_meta_model_python.base.property import Property
+
+
+class PropertyInterface(Property):
+    """Property interface class for testing."""
+
+    def __init__(self, name, characteristic=None):
+        self.name = name
+        self.characteristic = characteristic
+
+    def characteristic(self):
+        pass
+
+    def example_value(self):
+        pass
+
+    def is_abstract(self):
+        pass
+
+    def extends(self):
+        pass
+
+    def is_optional(self):
+        pass
+
+    def is_not_in_payload(self):
+        pass
+
+    def payload_name(self):
+        pass
+
+    @property
+    def parent_elements(self):
+        return None
+
+    @parent_elements.setter
+    def parent_elements(self, elements):
+        pass
+
+    def append_parent_element(self, element):
+        pass
+
+    def name(self):
+        return self.name
+
+    def preferred_names(self):
+        pass
+
+    def descriptions(self):
+        pass
+
+    def see(self):
+        pass
+
+    def urn(self):
+        pass
+
+    def meta_model_version(self):
+        pass
+
+
+class TestProperty:
+    """Property interface test suite."""
+
+    def test_effective_characteristic_empty(self):
+        interface = PropertyInterface("name")
+        result = interface.effective_characteristic
+
+        assert result is None
+
+    @mock.patch("esmf_aspect_meta_model_python.base.property.isinstance")
+    def test_effective_characteristic(self, isinstance_mock):
+        characteristic_mock = mock.MagicMock(name="characteristic")
+        characteristic_mock.base_characteristic = "base_characteristic"
+        isinstance_mock.side_effect = (True, False)
+        interface = PropertyInterface("name", characteristic_mock)
+        result = interface.effective_characteristic
+
+        assert result == "base_characteristic"
+        isinstance_mock.assert_has_calls(
+            [
+                mock.call(characteristic_mock, Trait),
+                mock.call("base_characteristic", Trait),
+            ]
+        )

core/esmf-aspect-meta-model-python/tests/unit/base/test_property_func.py

@@ -0,0 +1,71 @@
+"""Property Func interface test suite."""
+
+from unittest import mock
+
+import pytest
+
+from esmf_aspect_meta_model_python.base.property_func import PropertyFunc
+
+
+class TestPropertyFunc:
+    """Property Func interface test suite."""
+
+    def test_fget_name(self):
+        callable_property_mock = mock.MagicMock(name="callable_property")
+        callable_property_mock.fget.__name__ = "test_name"
+        result = PropertyFunc.fget_name(callable_property_mock)
+
+        assert result == "test_name"
+
+    def test_fget_name_raises_attribute_error(self):
+        with pytest.raises(AttributeError) as error:
+            PropertyFunc.fget_name(None)
+
+        assert str(error.value) == "Unable to execute fget.__name__ for this argument."
+
+    def test_has_properties(self):
+        class TestClass:
+            def __init__(self, a, b):
+                self._a = a
+                self._b = b
+
+            @property
+            def a(self):
+                return self._a
+
+            @property
+            def b(self):
+                return self._b
+
+        obj = TestClass("value_1", "value_2")
+        result = PropertyFunc.has_properties(obj, TestClass.a, TestClass.b)
+
+        assert result is True
+
+    def test_has_properties_missing_property(self):
+        class BaseTestClass:
+            def __init__(self, a, b):
+                self._a = a
+                self._b = b
+
+            @property
+            def a(self):
+                return self._a
+
+            @property
+            def b(self):
+                return self._b
+
+        class TestClass:
+            def __init__(self, a, b):
+                self._a = a
+                self._b = b
+
+            @property
+            def a(self):
+                return self._a
+
+        obj = TestClass("value_1", "value_2")
+        result = PropertyFunc.has_properties(obj, BaseTestClass.a, BaseTestClass.b)
+
+        assert result is False

core/esmf-aspect-meta-model-python/tests/unit/impl/characteristics/test_characteristic.py

@@ -2,6 +2,8 @@
 
 from unittest import mock
 
+import pytest
+
 from esmf_aspect_meta_model_python.impl import DefaultCharacteristic
 
 
@@ -21,6 +23,12 @@ def test_init(self, super_mock, isinstance_mock):
         assert result._data_type == self.data_type_mock
         self.data_type_mock.append_parent_element.assert_called_once_with(result)
 
+    def test_init_raise_exception(self):
+        with pytest.raises(ValueError) as error:
+            DefaultCharacteristic(self.meta_model_mock, None)
+
+        assert str(error.value) == "Attribute 'data_type' is required for Characteristic class."
+
     @mock.patch("esmf_aspect_meta_model_python.impl.characteristics.default_characteristic.BaseImpl.__init__")
     def test_data_type(self, _):
         characteristic = DefaultCharacteristic(self.meta_model_mock, self.data_type_mock)

core/esmf-aspect-meta-model-python/tests/unit/impl/test_value.py

@@ -0,0 +1,18 @@
+"""DefaultValue class unit tests suit."""
+
+from unittest import mock
+
+from esmf_aspect_meta_model_python.impl import DefaultValue
+
+
+class TestDefaultValue:
+    """DefaultValue unit tests class."""
+
+    meta_model_mock = mock.MagicMock(name="meta_model_base_attributes")
+
+    @mock.patch("esmf_aspect_meta_model_python.impl.default_unit.BaseImpl.__init__")
+    def test_init(self, super_mock):
+        result = DefaultValue(self.meta_model_mock, "value")
+
+        super_mock.assert_called_once_with(self.meta_model_mock)
+        assert result.value == "value"