aas-core-codegen 0.0.16__py3-none-any.whl

dev/tests/intermediate/test_hierarchy.py

@@ -0,0 +1,221 @@
+# pylint: disable=missing-docstring
+
+import textwrap
+import unittest
+
+from aas_core_codegen.intermediate import _hierarchy as intermediate_hierarchy
+from aas_core_codegen.common import Identifier
+
+import tests.common
+
+
+class Test_ontology_ok(unittest.TestCase):
+    def test_no_ancestors(self) -> None:
+        symbol_table, error = tests.common.parse_source(
+            textwrap.dedent(
+                """\
+                class Something:
+                    pass
+
+                __version__ = "dummy"
+                __xml_namespace__ = "https://dummy.com"
+                """
+            )
+        )
+
+        assert error is None, tests.common.most_underlying_messages(error)
+        assert symbol_table is not None
+
+        ontology, errors = intermediate_hierarchy.map_symbol_table_to_ontology(
+            symbol_table
+        )
+        assert errors is None, f"{errors=}"
+        assert ontology is not None
+
+        ancestors = ontology.list_ancestors(
+            cls=symbol_table.must_find_class(Identifier("Something"))
+        )
+
+        ancestor_names = [cls.name for cls in ancestors]
+        self.assertListEqual([], ancestor_names)
+
+    def test_complex_graph(self) -> None:
+        symbol_table, error = tests.common.parse_source(
+            textwrap.dedent(
+                """\
+                @abstract
+                class Another_grand_parent:
+                    pass
+
+                @abstract
+                class Grand_parent:
+                    pass
+
+                @abstract
+                class Parent(Grand_parent, Another_grand_parent):
+                    pass
+
+                @abstract
+                class Another_parent(Grand_parent, Another_grand_parent):
+                    pass
+
+                class Something(Parent, Another_parent):
+                    pass
+
+                __version__ = "dummy"
+                __xml_namespace__ = "https://dummy.com"
+                """
+            )
+        )
+
+        assert error is None, tests.common.most_underlying_messages(error)
+        assert symbol_table is not None
+
+        ontology, errors = intermediate_hierarchy.map_symbol_table_to_ontology(
+            symbol_table
+        )
+        assert errors is None, f"{errors=}"
+        assert ontology is not None
+
+        ancestors = ontology.list_ancestors(
+            cls=symbol_table.must_find_class(Identifier("Something"))
+        )
+
+        ancestor_names = [cls.name for cls in ancestors]
+
+        self.assertListEqual(
+            [
+                "Another_grand_parent",
+                "Grand_parent",
+                "Another_parent",
+                "Another_grand_parent",
+                "Grand_parent",
+                "Parent",
+            ],
+            ancestor_names,
+        )
+
+
+class Test_ontology_fail(unittest.TestCase):
+    def test_duplicate_properties_in_ancestors(self) -> None:
+        symbol_table, error = tests.common.parse_source(
+            textwrap.dedent(
+                """\
+                @abstract
+                class SomethingAbstract:
+                    x: int
+
+                @abstract
+                class Something(SomethingAbstract):
+                    x: int
+
+                __version__ = "dummy"
+                __xml_namespace__ = "https://dummy.com"
+                """
+            )
+        )
+        assert error is None, tests.common.most_underlying_messages(error)
+        assert symbol_table is not None
+
+        _, errors = intermediate_hierarchy.map_symbol_table_to_ontology(symbol_table)
+        assert errors is not None and len(errors) == 1
+
+        self.assertEqual(
+            "The property has already been defined "
+            "in the ancestor class SomethingAbstract: x",
+            tests.common.most_underlying_messages(errors[0]),
+        )
+
+    def test_duplicate_methods_in_ancestors(self) -> None:
+        symbol_table, error = tests.common.parse_source(
+            textwrap.dedent(
+                """\
+                @abstract
+                class SomethingAbstract:
+                    def do_something(self) -> None:
+                        pass
+
+                @abstract
+                class Something(SomethingAbstract):
+                    def do_something(self) -> None:
+                        pass
+
+                __version__ = "dummy"
+                __xml_namespace__ = "https://dummy.com"
+                """
+            )
+        )
+        assert error is None, tests.common.most_underlying_messages(error)
+        assert symbol_table is not None
+
+        _, errors = intermediate_hierarchy.map_symbol_table_to_ontology(symbol_table)
+        assert errors is not None and len(errors) == 1
+
+        self.assertEqual(
+            "The method has already been defined "
+            "in the ancestor class SomethingAbstract: do_something",
+            tests.common.most_underlying_messages(errors[0]),
+        )
+
+    def test_missing_constructor_when_the_parent_has_one(self) -> None:
+        symbol_table, error = tests.common.parse_source(
+            textwrap.dedent(
+                """\
+                @abstract
+                class SomethingAbstract:
+                    def __init__(self, x: int) -> None:
+                        pass
+
+                class Something(SomethingAbstract):
+                    pass
+
+                __version__ = "dummy"
+                __xml_namespace__ = "https://dummy.com"
+                """
+            )
+        )
+        assert error is None, tests.common.most_underlying_messages(error)
+        assert symbol_table is not None
+
+        _, errors = intermediate_hierarchy.map_symbol_table_to_ontology(symbol_table)
+        assert errors is not None and len(errors) == 1
+
+        self.assertEqual(
+            "The class Something does not specify a constructor, "
+            "but the ancestor class SomethingAbstract specifies a constructor "
+            "with arguments: self, x",
+            tests.common.most_underlying_messages(errors[0]),
+        )
+
+    def test_cycle_inheritance(self) -> None:
+        symbol_table, error = tests.common.parse_source(
+            textwrap.dedent(
+                """\
+                @abstract
+                class Cycle(Something):
+                    pass
+
+                @abstract
+                class Something(Cycle):
+                    pass
+
+                __version__ = "dummy"
+                __xml_namespace__ = "https://dummy.com"
+                """
+            )
+        )
+        assert error is None, tests.common.most_underlying_messages(error)
+        assert symbol_table is not None
+
+        _, errors = intermediate_hierarchy.map_symbol_table_to_ontology(symbol_table)
+        assert errors is not None and len(errors) == 1
+
+        self.assertEqual(
+            "Expected no cycles in the inheritance, "
+            "but the class Cycle has been observed in a cycle",
+            tests.common.most_underlying_messages(errors[0]),
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

dev/tests/intermediate/test_revm.py

@@ -0,0 +1,134 @@
+# pylint: disable=missing-docstring
+
+import os
+import pathlib
+import unittest
+from typing import List, Tuple, Optional
+
+from aas_core_codegen.parse import retree as parse_retree
+from aas_core_codegen.intermediate import revm as intermediate_revm
+
+import tests.common
+
+
+class Test_against_recorded(unittest.TestCase):
+    def test_cases(self) -> None:
+        repo_root = pathlib.Path(os.path.realpath(__file__)).parent.parent.parent.parent
+        test_cases_dir = repo_root / "dev/test_data/intermediate_revm"
+
+        assert test_cases_dir.exists(), f"{test_cases_dir=}"
+        assert test_cases_dir.is_dir(), f"{test_cases_dir=}"
+
+        # The expected cases should have no errors.
+        expected_pths = sorted((test_cases_dir / "expected").glob("**/pattern.regex"))
+        regex_pths_expected_exception = [
+            (pth, False) for pth in expected_pths
+        ]  # type: List[Tuple[pathlib.Path, bool]]
+
+        unexpected_pths = sorted(
+            (test_cases_dir / "unexpected").glob("**/pattern.regex")
+        )
+        regex_pths_expected_exception.extend((pth, True) for pth in unexpected_pths)
+
+        for regex_pth, expected_exception in regex_pths_expected_exception:
+            case_dir = regex_pth.parent
+
+            try:
+                regex_text = regex_pth.read_text(encoding="utf-8")
+            except Exception as exception:
+                raise AssertionError(
+                    f"Unexpected exception when reading "
+                    f"from {regex_pth.relative_to(repo_root)}"
+                ) from exception
+
+            try:
+                regex, error = parse_retree.parse([regex_text])
+            except Exception as exception:
+                raise AssertionError(
+                    f"Unexpected exception in parsing "
+                    f"the regex pattern {regex_text!r} "
+                    f"from {regex_pth.relative_to(repo_root)}"
+                ) from exception
+
+            if error is not None:
+                regex_line, pointer_line = parse_retree.render_pointer(error.cursor)
+                raise AssertionError(
+                    f"Unexpected error in parsing "
+                    f"the regex pattern "
+                    f"from {regex_pth.relative_to(repo_root)}:\n"
+                    f"{error.message}:\n"
+                    f"{regex_line}\n"
+                    f"{pointer_line}"
+                )
+
+            assert regex is not None
+
+            program = None  # type: Optional[intermediate_revm.NodeOrLeaf]
+            caught = None  # type: Optional[Exception]
+
+            try:
+                program = intermediate_revm.translate(regex=regex)
+            except Exception as exception:
+                caught = exception
+
+            if not expected_exception and caught is not None:
+                raise AssertionError(
+                    f"Expected no errors in the test "
+                    f"case {case_dir.relative_to(test_cases_dir)}, but got:\n"
+                    f"{caught}"
+                ) from caught
+
+            elif expected_exception and caught is None:
+                raise AssertionError(
+                    f"Expected exception in the test "
+                    f"case {case_dir.relative_to(test_cases_dir)}, but got none."
+                )
+
+            else:
+                pass
+
+            expected_program_pth = case_dir / "program.txt"
+            expected_exception_pth = case_dir / "exception.txt"
+
+            if expected_exception:
+                assert program is None
+                assert caught is not None
+
+                caught_str = str(caught)
+
+                if tests.common.RERECORD:
+                    expected_program_pth.unlink(missing_ok=True)
+                    expected_exception_pth.write_text(caught_str, encoding="utf-8")
+                else:
+                    assert not expected_program_pth.exists(), (
+                        f"Unexpected program stored in the test case "
+                        f"where we expect an exception: {expected_program_pth}"
+                    )
+                    expected_caught_str = expected_exception_pth.read_text(
+                        encoding="utf-8"
+                    )
+                    self.assertEqual(expected_caught_str, caught_str, f"{case_dir=}")
+
+            else:
+                assert program is not None
+                assert caught is None
+
+                program_str = intermediate_revm.dump(program)
+
+                if tests.common.RERECORD:
+                    expected_program_pth.write_text(program_str, encoding="utf-8")
+                    expected_exception_pth.unlink(missing_ok=True)
+                else:
+                    assert not expected_exception_pth.exists(), (
+                        f"Unexpected exception stored in the test case "
+                        f"where we expect a program: {expected_exception_pth}"
+                    )
+
+                    expected_program_str = expected_program_pth.read_text(
+                        encoding="utf-8"
+                    )
+                    self.assertEqual(expected_program_str, program_str, f"{case_dir=}")
+
+
+if __name__ == "__main__":
+    unittest.main()

dev/tests/intermediate/test_translate.py

@@ -0,0 +1,337 @@
+# pylint: disable=missing-docstring
+
+import os
+import pathlib
+import textwrap
+import unittest
+from typing import List, Tuple
+
+from aas_core_codegen import intermediate
+from aas_core_codegen.intermediate import doc as intermediate_doc
+from aas_core_codegen.common import Identifier
+
+import tests.common
+
+
+class Test_in_lining_of_constructor_statements(unittest.TestCase):
+    def test_case(self) -> None:
+        source = textwrap.dedent(
+            """\
+            @abstract
+            class VeryAbstract:
+                some_property: int
+
+                @require(lambda some_property: some_property > 0)
+                def __init__(self, some_property: int) -> None:
+                    self.some_property = some_property
+
+
+            @abstract
+            class SomethingAbstract(VeryAbstract):
+                another_property: int
+
+                @require(lambda another_property: another_property > 0)
+                def __init__(self, some_property: int, another_property: int) -> None:
+                    VeryAbstract.__init__(self, some_property)
+                    self.another_property = another_property
+
+            class Concrete(SomethingAbstract):
+                yet_another_property: int
+
+                @require(lambda yet_another_property: yet_another_property > 0)
+                def __init__(
+                        self,
+                        some_property: int,
+                        another_property: int,
+                        yet_another_property: int
+                ) -> None:
+                    SomethingAbstract.__init__(self, some_property, another_property)
+                    self.yet_another_property = yet_another_property
+
+
+            __version__ = "dummy"
+            __xml_namespace__ = "https://dummy.com"
+            """
+        )
+
+        symbol_table, error = tests.common.translate_source_to_intermediate(
+            source=source
+        )
+        assert error is None, tests.common.most_underlying_messages(error)
+
+        assert symbol_table is not None
+
+        concrete = symbol_table.must_find_class(Identifier("Concrete"))
+
+        self.assertEqual(
+            ["some_property", "another_property", "yet_another_property"],
+            [stmt.name for stmt in concrete.constructor.inlined_statements],
+        )
+
+
+class Test_parsing_docstrings(unittest.TestCase):
+    def test_class_reference(self) -> None:
+        source = textwrap.dedent(
+            '''\
+            class Some_class:
+                """
+                This is some documentation.
+
+                Nested reference :class:`Some_class`
+                """
+
+            __version__ = "dummy"
+            __xml_namespace__ = "https://dummy.com"
+            '''
+        )
+
+        symbol_table, error = tests.common.translate_source_to_intermediate(
+            source=source
+        )
+        assert error is None, tests.common.most_underlying_messages(error)
+
+        assert symbol_table is not None
+
+        some_class = symbol_table.must_find_class(Identifier("Some_class"))
+
+        assert some_class.description is not None
+        assert len(some_class.description.remarks) == 1
+
+        references_to_our_types = list(
+            some_class.description.remarks[0].findall(
+                condition=intermediate_doc.ReferenceToOurType
+            )
+        )
+
+        self.assertEqual(1, len(references_to_our_types))
+        self.assertIsInstance(references_to_our_types[0].our_type, intermediate.Class)
+
+    def test_constraint_and_constraintref(self) -> None:
+        source = textwrap.dedent(
+            '''\
+            class Some_class:
+                """
+                This is some documentation.
+
+                See :constraintref:`AAS-001`.
+
+                :constraint AAS-001:
+                    some constraint
+                """
+
+            __version__ = "dummy"
+            __xml_namespace__ = "https://dummy.com"
+            '''
+        )
+
+        symbol_table, error = tests.common.translate_source_to_intermediate(
+            source=source
+        )
+        assert error is None, tests.common.most_underlying_messages(error)
+
+        assert symbol_table is not None
+
+        some_class = symbol_table.must_find_class(Identifier("Some_class"))
+
+        assert some_class.description is not None
+        assert len(some_class.description.remarks) == 1
+
+        constraint_references = list(
+            some_class.description.remarks[0].findall(
+                condition=intermediate_doc.ReferenceToConstraint
+            )
+        )
+        self.assertEqual(1, len(constraint_references))
+        self.assertEqual("AAS-001", constraint_references[0].reference)
+
+        self.assertListEqual(
+            ["AAS-001"], list(some_class.description.constraints_by_identifier.keys())
+        )
+
+
+class Test_against_recorded(unittest.TestCase):
+    def test_cases(self) -> None:
+        repo_root = pathlib.Path(os.path.realpath(__file__)).parent.parent.parent.parent
+        test_cases_dir = repo_root / "dev/test_data/intermediate"
+
+        assert test_cases_dir.exists(), f"{test_cases_dir=}"
+        assert test_cases_dir.is_dir(), f"{test_cases_dir=}"
+
+        # The expected cases should have no errors.
+        expected_pths = sorted((test_cases_dir / "expected").glob("**/meta_model.py"))
+        meta_model_pths_expected_errors = [
+            (pth, False) for pth in expected_pths
+        ]  # type: List[Tuple[pathlib.Path, bool]]
+
+        unexpected_pths = sorted(
+            (test_cases_dir / "unexpected").glob("**/meta_model.py")
+        )
+
+        meta_model_pths_expected_errors.extend((pth, True) for pth in unexpected_pths)
+
+        for meta_model_pth, expected_errors in meta_model_pths_expected_errors:
+            case_dir = meta_model_pth.parent
+
+            try:
+                source = meta_model_pth.read_text(encoding="utf-8")
+            except Exception as exception:
+                raise AssertionError(
+                    f"Unexpected exception when reading "
+                    f"from {meta_model_pth.relative_to(repo_root)}"
+                ) from exception
+
+            try:
+                symbol_table, error = tests.common.translate_source_to_intermediate(
+                    source=source
+                )
+            except Exception as exception:
+                raise AssertionError(
+                    f"Unexpected exception in source-to-intermediate translation "
+                    f"for source {meta_model_pth.relative_to(repo_root)}"
+                ) from exception
+
+            if not expected_errors and error is not None:
+                raise AssertionError(
+                    f"Expected no errors in the test "
+                    f"case {case_dir.relative_to(test_cases_dir)}, but got:\n"
+                    f"{tests.common.most_underlying_messages(error)}"
+                )
+
+            elif expected_errors and error is None:
+                raise AssertionError(
+                    f"Expected errors in the test "
+                    f"case {case_dir.relative_to(test_cases_dir)}, but got none."
+                )
+
+            else:
+                pass
+
+            expected_symbol_table_pth = case_dir / "expected_symbol_table.txt"
+            expected_error_pth = case_dir / "expected_error.txt"
+
+            if expected_errors:
+                if expected_symbol_table_pth.exists():
+                    raise AssertionError(
+                        f"Unexpected recorded symbol table file when errors "
+                        f"are expected: {expected_symbol_table_pth}"
+                    )
+
+                assert error is not None
+
+                error_str = tests.common.most_underlying_messages(error)
+
+                if tests.common.RERECORD:
+                    expected_error_pth.write_text(error_str, encoding="utf-8")
+                else:
+                    expected_error_str = expected_error_pth.read_text(encoding="utf-8")
+                    self.assertEqual(expected_error_str, error_str, f"{case_dir=}")
+
+            else:
+                if expected_error_pth.exists():
+                    raise AssertionError(
+                        f"Unexpected recorded error file when no errors "
+                        f"are expected: {expected_error_pth}"
+                    )
+
+                assert symbol_table is not None
+
+                symbol_table_str = intermediate.dump(symbol_table)
+
+                if tests.common.RERECORD:
+                    # NOTE (mristin, 2023-11-07):
+                    # We have to write the bytes since Git considers too long text
+                    # files to be binaries. This is problematic when we re-record
+                    # on Windows and Linux due to the different line endings.
+                    # Therefore, we remove here carriage returns (``\r``) so that
+                    # we have the same representation on both operating systems.
+
+                    symbol_table_bytes = symbol_table_str.encode(
+                        "utf-8", errors="strict"
+                    ).replace(b"\r", b"")
+
+                    expected_symbol_table_pth.write_bytes(symbol_table_bytes)
+                else:
+                    try:
+                        # NOTE (mristin, 2023-11-07):
+                        # We assume that Python will automatically represent new lines
+                        # as ``\n`` so that it matches ``symbol_table_bytes`` above.
+
+                        expected_symbol_table_str = expected_symbol_table_pth.read_text(
+                            encoding="utf-8"
+                        )
+                    except Exception as exception:
+                        raise RuntimeError(
+                            f"Failed to read the file representing "
+                            f"the expected symbol table: {expected_symbol_table_pth}"
+                        ) from exception
+
+                    self.assertEqual(
+                        expected_symbol_table_str,
+                        symbol_table_str,
+                        f"{case_dir=}, {error=}",
+                    )
+
+    def test_real_meta_models(self) -> None:
+        repo_root = pathlib.Path(os.path.realpath(__file__)).parent.parent.parent.parent
+        test_cases_dir = repo_root / "dev/test_data/intermediate/real_meta_models"
+
+        for meta_model_pth in tests.common.REAL_META_MODEL_PATHS:
+            case_dir = test_cases_dir / meta_model_pth.stem
+
+            try:
+                source = meta_model_pth.read_text(encoding="utf-8")
+            except Exception as exception:
+                raise AssertionError(
+                    f"Unexpected exception when reading from {meta_model_pth}"
+                ) from exception
+
+            try:
+                symbol_table, error = tests.common.translate_source_to_intermediate(
+                    source=source
+                )
+            except Exception as exception:
+                if repo_root in meta_model_pth.parents:
+                    meta_model_pth_maybe_shorter = meta_model_pth.relative_to(repo_root)
+                else:
+                    meta_model_pth_maybe_shorter = meta_model_pth
+
+                raise AssertionError(
+                    f"Unexpected exception in source-to-intermediate translation "
+                    f"for source {meta_model_pth_maybe_shorter}"
+                ) from exception
+
+            if error is not None:
+                raise AssertionError(
+                    f"Expected no errors when translating "
+                    f"the real meta-model {meta_model_pth}, but got:\n"
+                    f"{tests.common.most_underlying_messages(error)}"
+                )
+
+            expected_symbol_table_pth = case_dir / "expected_symbol_table.txt"
+
+            assert symbol_table is not None
+
+            symbol_table_str = intermediate.dump(symbol_table)
+
+            if tests.common.RERECORD:
+                expected_symbol_table_pth.write_text(symbol_table_str, encoding="utf-8")
+            else:
+                try:
+                    expected_symbol_table_str = expected_symbol_table_pth.read_text(
+                        encoding="utf-8"
+                    )
+                except Exception as exception:
+                    raise RuntimeError(
+                        f"Failed to read the file representing "
+                        f"the expected symbol table: {expected_symbol_table_pth}"
+                    ) from exception
+
+                self.assertEqual(
+                    expected_symbol_table_str,
+                    symbol_table_str,
+                    f"{case_dir=}, {error=}",
+                )
+
+
+if __name__ == "__main__":
+    unittest.main()