Update pipeline

Author: Hanna-Shalamitskaya-EPAM

.github/workflows/push_request_check.yml

@@ -42,7 +42,16 @@ jobs:
           cd core/esmf-aspect-meta-model-python
           poetry run download-test-models
 
-      - name: run tests
+      - name: check test models
+        run: |
+          cd core/esmf-aspect-meta-model-python/tests/integration/java_models/resources
+          ls
+          cd valid
+          ls
+          cd org.eclipse.esmf.test
+          ls
+
+      - name: run test*s
         run: |
           cd core/esmf-aspect-meta-model-python
           poetry run tox -e py310

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

@@ -9,7 +9,7 @@
 #
 #   SPDX-License-Identifier: MPL-2.0
 
-import typing
+from typing import Any, Dict, List, Optional, Union
 
 import rdflib  # type: ignore
 
@@ -40,7 +40,7 @@ def _create_instance(self, element_node: Node) -> Enumeration:
 
         return DefaultEnumeration(meta_model_base_attributes, data_type, values)
 
-    def __to_enum_node_value(self, value_node: Node) -> typing.Dict:
+    def __to_enum_node_value(self, value_node: Node) -> Union[Dict, str]:
         """
         This method instantiates one possible value of an enumeration.
         :param value_node:  Node of the Graph that represents one enumeration value.
@@ -49,36 +49,37 @@ def __to_enum_node_value(self, value_node: Node) -> typing.Dict:
         - If value_node is a URIRef it will represent a value of a ComplexType
         :return: the one generated value of the enumeration
         """
-        value = {}
+        str_value: str = ""
+        dict_value: Dict = {}
 
-        if isinstance(value_node, rdflib.Literal):
+        if isinstance(value_node, rdflib.Literal) or (
+            isinstance(value_node, rdflib.URIRef) and value_node.find("#") == -1
+        ):
             # value represents a simple data type
-            value = value_node.toPython()
+            str_value = value_node.toPython()
 
         elif isinstance(value_node, rdflib.URIRef) or isinstance(value_node, rdflib.term.BNode):
             # value represents a complex data type
-            value_node_properties = self._aspect_graph.predicate_objects(value_node)
-            for property_urn, property_value in value_node_properties:
+            dict_value = {}
+
+            for property_urn, property_value in self._aspect_graph.predicate_objects(value_node):
                 if property_urn != rdflib.RDF.type and isinstance(property_urn, str):
                     property_name = property_urn.split("#")[1]
-                    actual_value: typing.Optional[typing.Any]
+
+                    actual_value: Optional[Any]
                     if self.__is_collection_value(property_urn):
                         actual_value = self.__instantiate_enum_collection(property_value)
                     else:
                         actual_value = self.__to_enum_node_value(property_value)
 
                     if property_name == "see":
-                        value.setdefault(property_name, []).append(actual_value)
+                        dict_value.setdefault(property_name, []).append(actual_value)
                     else:
-                        value[property_name] = actual_value
+                        dict_value[property_name] = actual_value
 
-            if isinstance(value_node, rdflib.URIRef):
-                if value_node.find("#") == -1:
-                    value = value_node.toPython()
-                else:
-                    value_node_name = value_node.split("#")[1]
-                    value_key = self._samm.get_urn(SAMM.name).toPython()
-                    value[value_key] = value_node_name  # type: ignore
+            value_node_name = value_node.split("#")[1]
+            value_key = self._samm.get_urn(SAMM.name).toPython()
+            dict_value[value_key] = value_node_name  # type: ignore
 
         elif value_node == rdflib.namespace.RDF.nil:
             # illegal node type for enumeration value (e.g., Blank Node)
@@ -87,21 +88,23 @@ def __to_enum_node_value(self, value_node: Node) -> typing.Dict:
                 f"a URI reference to a ComplexType. Values of type {type(value_node).__name__} are not allowed"
             )
 
-        return value
+        return str_value or dict_value
 
     def __is_collection_value(self, property_subject: str) -> bool:
         characteristic = self._aspect_graph.value(  # type: ignore
             subject=property_subject,
             predicate=self._samm.get_urn(SAMM.characteristic),
         )
         characteristic_type = self._aspect_graph.value(subject=characteristic, predicate=rdflib.RDF.type)
+
         return characteristic_type in self._sammc.collections_urns()
 
-    def __instantiate_enum_collection(self, value_list) -> typing.List[typing.Dict]:
+    def __instantiate_enum_collection(self, value_list) -> List[Union[Dict, str]]:
         """creates a collection as a child for enumeration characteristics"""
         value_node_list = RdfHelper.get_rdf_list_values(value_list, self._aspect_graph)
         values = []
         for value_node in value_node_list:
             value = self.__to_enum_node_value(value_node)
             values.append(value)
+
         return values

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

@@ -9,9 +9,10 @@
 #
 #   SPDX-License-Identifier: MPL-2.0
 
-from rdflib.term import Node
 from typing import Any
 
+from rdflib.term import Node
+
 from esmf_aspect_meta_model_python.base.value import Value
 from esmf_aspect_meta_model_python.impl.default_value import DefaultValue
 from esmf_aspect_meta_model_python.loader.instantiator_base import InstantiatorBase

core/esmf-aspect-meta-model-python/tests/integration/java_models/test_loading_aspects.py

@@ -12,10 +12,10 @@
 from scripts.constants import TestModelConstants
 from scripts.download_test_models import download_test_models
 
-
 # before start tests, download latest aspect test models with the next command
 # poetry run download-test-models
 
+
 def get_resources_folder_path() -> str:
     """Get a path for storing test models."""
     base_path = Path(__file__).parents[3].absolute()
@@ -35,7 +35,7 @@ def check_resources_folder():
 def get_test_files():
     """Get ttl models for testing."""
     resources_folder = get_resources_folder_path()
-    search_pattern = join(resources_folder, TestModelConstants.FOLDER_TO_EXTRACT, '**', '*.ttl')
+    search_pattern = join(resources_folder, TestModelConstants.FOLDER_TO_EXTRACT, "**", "*.ttl")
     test_model_files = glob(search_pattern, recursive=True)
 
     return test_model_files
@@ -62,7 +62,7 @@ def check_load_aspect_model(test_models):
     terminal_width = get_terminal_width()
     message = " SAMMGraph.load_aspect_model "
     fill_num = round((terminal_width - len(message)) / 2)
-    print("="*fill_num, message, "="*(terminal_width - len(message) - fill_num), "\n", sep="")
+    print("=" * fill_num, message, "=" * (terminal_width - len(message) - fill_num), "\n", sep="")
 
     for i, model_path in enumerate(test_models):
         model_name = os.path.splitext(os.path.basename(model_path))[0]
@@ -78,10 +78,12 @@ def check_load_aspect_model(test_models):
             except Exception as error:
                 status = "\033[91mFAILED\033[0m"
                 report["failed"] += 1
-                report["errors"].append({
-                    "model_name": model_name,
-                    "error": error,
-                })
+                report["errors"].append(
+                    {
+                        "model_name": model_name,
+                        "error": error,
+                    }
+                )
             else:
                 status = "\033[92mSUCCESS\033[0m"
                 report["passed"] += 1
@@ -124,10 +126,12 @@ def check_load_model_elements(test_models):
         except Exception as error:
             status = "\033[91mFAILED\033[0m"
             report["failed"] += 1
-            report["errors"].append({
-                "model_name": model_name,
-                "error": error,
-            })
+            report["errors"].append(
+                {
+                    "model_name": model_name,
+                    "error": error,
+                }
+            )
         else:
             status = "\033[92mSUCCESS\033[0m"
             report["passed"] += 1

core/esmf-aspect-meta-model-python/tests/unit/loader/instantiators/test_enumeration_instantiator.py

@@ -62,6 +62,18 @@ def test_to_enum_node_value_node_is_literal(self, isinstance_mock):
         assert result == "node_value"
         value_node_mock.toPython.assert_called_once()
 
+    @mock.patch("esmf_aspect_meta_model_python.loader.instantiator.enumeration_instantiator.isinstance")
+    def test_to_enum_node_value_node_is_ref(self, isinstance_mock):
+        isinstance_mock.side_effect = (False, True)
+        base_class_mock = mock.MagicMock(name="EnumerationInstantiator_class")
+        value_node_mock = mock.MagicMock(name="value_node")
+        value_node_mock.find.return_value = -1
+        value_node_mock.toPython.return_value = "node_value"
+        result = EnumerationInstantiator._EnumerationInstantiator__to_enum_node_value(base_class_mock, value_node_mock)
+
+        assert result == "node_value"
+        value_node_mock.toPython.assert_called_once()
+
     @mock.patch("esmf_aspect_meta_model_python.loader.instantiator.enumeration_instantiator.isinstance")
     def test_to_enum_node_value_node_is_URIRef_collection_value(self, isinstance_mock):
         isinstance_mock.side_effect = (False, True, True, True)
@@ -126,47 +138,20 @@ def test_to_enum_node_value_with_see_property(self, isinstance_mock):
         assert "value_key" in result
         assert result["value_key"] == "value_node_name"
         aspect_graph_mock.predicate_objects.assert_called_once_with("value_node#value_node_name")
-        base_class_mock._EnumerationInstantiator__is_collection_value.assert_has_calls([
-            mock.call("property_urn#see"),
-            mock.call("property_urn#see"),
-        ])
-        base_class_mock._EnumerationInstantiator__to_enum_node_value.assert_has_calls([
-            mock.call("property_value_1"),
-            mock.call("property_value_2"),
-        ])
-        samm_mock.get_urn.assert_called_once_with(SAMM.name)
-        value_mock.toPython.assert_called_once()
-
-    @mock.patch("esmf_aspect_meta_model_python.loader.instantiator.enumeration_instantiator.isinstance")
-    def test_to_enum_node_value_node_is_URIRef_not_collection_value(self, isinstance_mock):
-        isinstance_mock.side_effect = (False, True, True, True)
-        base_class_mock = mock.MagicMock(name="EnumerationInstantiator_class")
-        base_class_mock._EnumerationInstantiator__is_collection_value.return_value = False
-        base_class_mock._EnumerationInstantiator__to_enum_node_value.return_value = "some_value"
-        aspect_graph_mock = mock.MagicMock(name="aspect_graph")
-        aspect_graph_mock.predicate_objects.return_value = [
-            ("property_urn#property_name", "property_value"),
-        ]
-        base_class_mock._aspect_graph = aspect_graph_mock
-        samm_mock = mock.MagicMock(name="SAMM")
-        value_node_mock = mock.MagicMock(name="value_node")
-        value_node_mock.find.return_value = -1
-        value_node_mock.toPython.return_value = "value_node"
-        result = EnumerationInstantiator._EnumerationInstantiator__to_enum_node_value(
-            base_class_mock,
-            value_node_mock,
-        )
-
-        assert result == "value_node"
-        aspect_graph_mock.predicate_objects.assert_called_once_with(value_node_mock)
-        base_class_mock._EnumerationInstantiator__is_collection_value.assert_called_once_with(
-            "property_urn#property_name",
+        base_class_mock._EnumerationInstantiator__is_collection_value.assert_has_calls(
+            [
+                mock.call("property_urn#see"),
+                mock.call("property_urn#see"),
+            ]
         )
-        base_class_mock._EnumerationInstantiator__to_enum_node_value.assert_called_once_with(
-            "property_value",
+        base_class_mock._EnumerationInstantiator__to_enum_node_value.assert_has_calls(
+            [
+                mock.call("property_value_1"),
+                mock.call("property_value_2"),
+            ]
         )
-        value_node_mock.find.assert_called_once_with("#")
-        value_node_mock.toPython.assert_called_once()
+        samm_mock.get_urn.assert_called_once_with(SAMM.name)
+        value_mock.toPython.assert_called_once()
 
     @mock.patch("esmf_aspect_meta_model_python.loader.instantiator.enumeration_instantiator.isinstance")
     def test_to_enum_node_value_node_is_BNode(self, isinstance_mock):