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

dev/tests/python/test_xml_playground.py

@@ -0,0 +1,254 @@
+# pylint: disable=missing-docstring
+
+# NOTE (mristin, 2022-10-04):
+# This is not really test suite, but a playground to document how streaming XML
+# working in Python.
+import io
+import unittest
+import xml.etree.ElementTree as ET
+
+
+class Test_XML_stream(unittest.TestCase):
+    def test_self_closing_element_without_namespace(self) -> None:
+        text = """\
+<environment/>
+"""
+
+        reader = io.StringIO(text)
+
+        writer = io.StringIO()
+
+        for event, element in ET.iterparse(reader, events=["start", "end"]):
+            prefix, has_prefix, postfix = element.tag.rpartition("}")
+
+            writer.write(f"event is {event!r}\n")
+            writer.write(f"element.tag is {element.tag!r}\n")
+            writer.write(
+                f"prefix, has_prefix, postfix is {prefix, has_prefix, postfix!r}\n"
+            )
+            writer.write(f"element.text is {element.text!r}\n")
+
+        self.assertEqual(
+            """\
+event is 'start'
+element.tag is 'environment'
+prefix, has_prefix, postfix is ('', '', 'environment')
+element.text is None
+event is 'end'
+element.tag is 'environment'
+prefix, has_prefix, postfix is ('', '', 'environment')
+element.text is None
+""",
+            writer.getvalue(),
+        )
+
+    def test_cdata_single(self) -> None:
+        text = """\
+<something>
+<![CDATA[crazy < > content]]>
+</something>
+"""
+
+        reader = io.StringIO(text)
+
+        writer = io.StringIO()
+
+        for event, element in ET.iterparse(reader, events=["start", "end"]):
+            writer.write(f"event is {event!r}\n")
+            writer.write(f"element.tag is {element.tag!r}\n")
+            writer.write(f"element.text is {element.text!r}\n")
+            writer.write(f"element.tail is {element.tail!r}\n")
+
+        self.assertEqual(
+            """\
+event is 'start'
+element.tag is 'something'
+element.text is '\\ncrazy < > content\\n'
+element.tail is None
+event is 'end'
+element.tag is 'something'
+element.text is '\\ncrazy < > content\\n'
+element.tail is None
+""",
+            writer.getvalue(),
+        )
+
+    def test_cdata_enclosed(self) -> None:
+        text = """\
+<something>
+<![CDATA[
+crazy < > content
+]]>
+</something>
+"""
+
+        reader = io.StringIO(text)
+
+        writer = io.StringIO()
+
+        for event, element in ET.iterparse(reader, events=["start", "end"]):
+            writer.write(f"event is {event!r}\n")
+            writer.write(f"element.tag is {element.tag!r}\n")
+            writer.write(f"element.text is {element.text!r}\n")
+            writer.write(f"element.tail is {element.tail!r}\n")
+
+        self.assertEqual(
+            """\
+event is 'start'
+element.tag is 'something'
+element.text is '\\n\\ncrazy < > content\\n\\n'
+element.tail is None
+event is 'end'
+element.tag is 'something'
+element.text is '\\n\\ncrazy < > content\\n\\n'
+element.tail is None
+""",
+            writer.getvalue(),
+        )
+
+    def test_self_closing_element_with_namespace(self) -> None:
+        text = """\
+<environment xmlns="https://admin-shell.io/aas/3/0/RC02"/>
+"""
+
+        reader = io.StringIO(text)
+
+        writer = io.StringIO()
+
+        for event, element in ET.iterparse(reader, events=["start", "end"]):
+            prefix, has_prefix, postfix = element.tag.rpartition("}")
+
+            writer.write(f"event is {event!r}\n")
+            writer.write(f"element.tag is {element.tag!r}\n")
+            writer.write(
+                f"prefix, has_prefix, postfix is {prefix, has_prefix, postfix!r}\n"
+            )
+
+        self.assertEqual(
+            """\
+event is 'start'
+element.tag is '{https://admin-shell.io/aas/3/0/RC02}environment'
+prefix, has_prefix, postfix is ('{https://admin-shell.io/aas/3/0/RC02', '}', 'environment')
+event is 'end'
+element.tag is '{https://admin-shell.io/aas/3/0/RC02}environment'
+prefix, has_prefix, postfix is ('{https://admin-shell.io/aas/3/0/RC02', '}', 'environment')
+""",
+            writer.getvalue(),
+        )
+
+    def test_nested_elements_with_text_and_tail(self) -> None:
+        text = """\
+<something>some prefix<another>another text</another>some suffix</something>"""
+
+        reader = io.StringIO(text)
+
+        writer = io.StringIO()
+
+        for event, element in ET.iterparse(reader, events=["start", "end"]):
+            writer.write(f"event is {event!r}\n")
+            writer.write(f"element.tag is {element.tag!r}\n")
+            writer.write(f"element.text is {element.text!r}\n")
+            writer.write(f"element.tail is {element.tail!r}\n")
+
+        self.assertEqual(
+            """\
+event is 'start'
+element.tag is 'something'
+element.text is 'some prefix'
+element.tail is None
+event is 'start'
+element.tag is 'another'
+element.text is 'another text'
+element.tail is 'some suffix'
+event is 'end'
+element.tag is 'another'
+element.text is 'another text'
+element.tail is 'some suffix'
+event is 'end'
+element.tag is 'something'
+element.text is 'some prefix'
+element.tail is None
+""",
+            writer.getvalue(),
+        )
+
+    def test_escapes_in_text(self) -> None:
+        text = """\
+<something>&#x4D;</something>"""
+
+        reader = io.StringIO(text)
+
+        writer = io.StringIO()
+
+        for event, element in ET.iterparse(reader, events=["start", "end"]):
+            writer.write(f"event is {event!r}\n")
+            writer.write(f"element.tag is {element.tag!r}\n")
+            writer.write(f"element.text is {element.text!r}\n")
+
+        self.assertEqual(
+            """\
+event is 'start'
+element.tag is 'something'
+element.text is 'M'
+event is 'end'
+element.tag is 'something'
+element.text is 'M'
+""",
+            writer.getvalue(),
+        )
+
+    def test_attrib(self) -> None:
+        text = """\
+<something that="ok"></something>"""
+
+        reader = io.StringIO(text)
+
+        writer = io.StringIO()
+
+        for event, element in ET.iterparse(reader, events=["start", "end"]):
+            writer.write(f"event is {event!r}\n")
+            writer.write(f"element.tag is {element.tag!r}\n")
+            writer.write(f"element.attrib is {element.attrib!r}\n")
+
+        self.assertEqual(
+            """\
+event is 'start'
+element.tag is 'something'
+element.attrib is {'that': 'ok'}
+event is 'end'
+element.tag is 'something'
+element.attrib is {'that': 'ok'}
+""",
+            writer.getvalue(),
+        )
+
+    def test_comment(self) -> None:
+        text = """\
+<something>
+<!-- some comment -->
+</something>"""
+
+        reader = io.StringIO(text)
+
+        writer = io.StringIO()
+
+        for event, element in ET.iterparse(reader, events=["start", "end"]):
+            writer.write(f"event is {event!r}\n")
+            writer.write(f"element.tag is {element.tag!r}\n")
+            writer.write(f"element.text is {element.text!r}\n")
+
+        self.assertEqual(
+            """\
+event is 'start'
+element.tag is 'something'
+element.text is '\\n\\n'
+event is 'end'
+element.tag is 'something'
+element.text is '\\n\\n'
+""",
+            writer.getvalue(),
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

dev/tests/python_protobuf/test_main.py

@@ -0,0 +1,111 @@
+# pylint: disable=missing-docstring
+
+import contextlib
+import io
+import os
+import pathlib
+import tempfile
+import unittest
+
+import aas_core_codegen.main
+import aas_core_codegen.python_protobuf.main
+import tests.common
+
+
+class Test_against_recorded(unittest.TestCase):
+    def test_against_meta_models(self) -> None:
+        repo_root = pathlib.Path(os.path.realpath(__file__)).parent.parent.parent.parent
+        base_case_dir = (
+            repo_root / "dev" / "test_data" / "python_protobuf" / "test_main"
+        )
+
+        test_cases = tests.common.test_cases_from_base_case_dir(
+            base_case_dir=base_case_dir
+        ) + tests.common.test_cases_from_real_world_models(
+            base_case_dir=base_case_dir,
+            real_meta_model_paths=tests.common.REAL_META_MODEL_PATHS,
+        )
+
+        for test_case in test_cases:
+            snippets_dir = test_case.case_dir / "input/snippets"
+            assert snippets_dir.exists() and snippets_dir.is_dir(), snippets_dir
+
+            expected_output_dir = test_case.case_dir / "expected_output"
+
+            with contextlib.ExitStack() as exit_stack:
+                if tests.common.RERECORD:
+                    output_dir = expected_output_dir
+                    expected_output_dir.mkdir(exist_ok=True, parents=True)
+                else:
+                    assert (
+                        expected_output_dir.exists() and expected_output_dir.is_dir()
+                    ), expected_output_dir
+
+                    # pylint: disable=consider-using-with
+                    tmp_dir = tempfile.TemporaryDirectory()
+                    exit_stack.push(tmp_dir)
+                    output_dir = pathlib.Path(tmp_dir.name)
+
+                params = aas_core_codegen.main.Parameters(
+                    model_path=test_case.model_path,
+                    target=aas_core_codegen.main.Target.PYTHON_PROTOBUF,
+                    snippets_dir=snippets_dir,
+                    output_dir=output_dir,
+                )
+
+                stdout = io.StringIO()
+                stderr = io.StringIO()
+
+                return_code = aas_core_codegen.main.execute(
+                    params=params, stdout=stdout, stderr=stderr
+                )
+
+                if stderr.getvalue() != "":
+                    raise AssertionError(
+                        f"Expected no stderr on valid models, but got:\n"
+                        f"{stderr.getvalue()}"
+                    )
+
+                self.assertEqual(
+                    0, return_code, "Expected 0 return code on valid models"
+                )
+
+                stdout_pth = expected_output_dir / "stdout.txt"
+                normalized_stdout = stdout.getvalue().replace(
+                    str(output_dir), "<output dir>"
+                )
+
+                if tests.common.RERECORD:
+                    stdout_pth.write_text(normalized_stdout, encoding="utf-8")
+                else:
+                    self.assertEqual(
+                        normalized_stdout,
+                        stdout_pth.read_text(encoding="utf-8"),
+                        stdout_pth,
+                    )
+
+                for relevant_rel_pth in [
+                    pathlib.Path("pbization.py"),
+                ]:
+                    expected_pth = expected_output_dir / relevant_rel_pth
+                    output_pth = output_dir / relevant_rel_pth
+
+                    if not output_pth.exists():
+                        raise FileNotFoundError(
+                            f"The output file is missing: {output_pth}"
+                        )
+
+                    if tests.common.RERECORD:
+                        expected_pth.write_text(
+                            output_pth.read_text(encoding="utf-8"), encoding="utf-8"
+                        )
+                    else:
+                        self.assertEqual(
+                            expected_pth.read_text(encoding="utf-8"),
+                            output_pth.read_text(encoding="utf-8"),
+                            f"The files {expected_pth} and {output_pth} do not match.",
+                        )
+
+
+if __name__ == "__main__":
+    unittest.main()

dev/tests/rdf_shacl/test_common.py

@@ -0,0 +1,32 @@
+# pylint: disable=missing-docstring
+
+import unittest
+
+from aas_core_codegen.rdf_shacl import common as rdf_shacl_common
+
+
+class Test_string_literal(unittest.TestCase):
+    def test_empty(self) -> None:
+        self.assertEqual('""', rdf_shacl_common.string_literal(""))
+
+    def test_no_escapes(self) -> None:
+        self.assertEqual('"something"', rdf_shacl_common.string_literal("something"))
+
+    def test_escape_single_line(self) -> None:
+        self.assertEqual(
+            '"some\\"thing"', rdf_shacl_common.string_literal('some"thing')
+        )
+
+    def test_multi_line_no_escape(self) -> None:
+        self.assertEqual(
+            r'"some\nthing"', rdf_shacl_common.string_literal("some\nthing")
+        )
+
+    def test_multi_line_escape(self) -> None:
+        self.assertEqual(
+            r'"some\nthi\"ng"', rdf_shacl_common.string_literal('some\nthi"ng')
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

dev/tests/rdf_shacl/test_description.py

@@ -0,0 +1,223 @@
+# pylint: disable=missing-docstring
+
+import textwrap
+import unittest
+from typing import Sequence, List
+
+import tests.description
+
+from aas_core_codegen.rdf_shacl import _description as rdf_shacl_description
+
+
+def tokens_are_equal(
+    that: Sequence[rdf_shacl_description.Token],
+    other: Sequence[rdf_shacl_description.Token],
+) -> bool:
+    if len(that) != len(other):
+        return False
+
+    for me, you in zip(that, other):
+        if type(me) != type(you):  # pylint: disable=unidiomatic-typecheck
+            return False
+
+        if isinstance(me, rdf_shacl_description.TokenText):
+            assert isinstance(you, rdf_shacl_description.TokenText)
+            if me.content != you.content:
+                return False
+
+    return True
+
+
+class Test_renderer(unittest.TestCase):
+    def test_bullet_list(self) -> None:
+        text = textwrap.dedent(
+            """\
+            Some bullets:
+
+            * Test
+              me
+            * Well
+            """
+        )
+        doc = tests.description.parse_restructured_text(text)
+
+        renderer = rdf_shacl_description.Renderer()
+        got, error = renderer.transform(element=doc)
+        assert error is None, f"{error}="
+        assert got is not None
+
+        expected = [
+            rdf_shacl_description.TokenText("Some bullets:"),
+            rdf_shacl_description.TokenParagraphBreak(),
+            rdf_shacl_description.TokenText("* "),
+            rdf_shacl_description.TokenText("Test me"),
+            rdf_shacl_description.TokenLineBreak(),
+            rdf_shacl_description.TokenText("* "),
+            rdf_shacl_description.TokenText("Well"),
+        ]
+        self.assertTrue(
+            tokens_are_equal(expected, got), f"Expected {expected!r}, got {got!r}"
+        )
+
+    def test_two_consecutive_notes(self) -> None:
+        text = textwrap.dedent(
+            """\
+            Some text.
+
+            .. note::
+
+                A single paragraph in the note.
+
+            .. note::
+
+                Another note.
+
+                Yet another paragraph.
+
+            Paragraph at root.
+            """
+        )
+
+        doc = tests.description.parse_restructured_text(text)
+        renderer = rdf_shacl_description.Renderer()
+        got, error = renderer.transform(element=doc)
+
+        assert error is None, f"{error}="
+        assert got is not None
+
+        expected = [
+            rdf_shacl_description.TokenText("Some text."),
+            rdf_shacl_description.TokenParagraphBreak(),
+            rdf_shacl_description.TokenText("NOTE:"),
+            rdf_shacl_description.TokenLineBreak(),
+            rdf_shacl_description.TokenText("A single paragraph in the note."),
+            rdf_shacl_description.TokenParagraphBreak(),
+            rdf_shacl_description.TokenText("NOTE:"),
+            rdf_shacl_description.TokenLineBreak(),
+            rdf_shacl_description.TokenText("Another note."),
+            rdf_shacl_description.TokenParagraphBreak(),
+            rdf_shacl_description.TokenText("Yet another paragraph."),
+            rdf_shacl_description.TokenParagraphBreak(),
+            rdf_shacl_description.TokenText("Paragraph at root."),
+        ]
+        self.assertTrue(
+            tokens_are_equal(expected, got), f"Expected {expected!r}, got {got!r}"
+        )
+
+
+class Test_without_redundant_breaks(unittest.TestCase):
+    def test_empty(self) -> None:
+        got = rdf_shacl_description.without_redundant_breaks([])
+        expected = []  # type: List[rdf_shacl_description.Token]
+        self.assertTrue(
+            tokens_are_equal(expected, got), f"Expected {expected!r}, got {got!r}"
+        )
+
+    def test_text(self) -> None:
+        got = rdf_shacl_description.without_redundant_breaks(
+            [rdf_shacl_description.TokenText("something")]
+        )
+
+        expected = [rdf_shacl_description.TokenText("something")]
+
+        self.assertTrue(
+            tokens_are_equal(expected, got), f"Expected {expected!r}, got {got!r}"
+        )
+
+    def test_consecutive_line_breaks(self) -> None:
+        got = rdf_shacl_description.without_redundant_breaks(
+            [
+                rdf_shacl_description.TokenText("something"),
+                rdf_shacl_description.TokenLineBreak(),
+                rdf_shacl_description.TokenLineBreak(),
+                rdf_shacl_description.TokenText("else"),
+            ]
+        )
+
+        expected = [
+            rdf_shacl_description.TokenText("something"),
+            rdf_shacl_description.TokenLineBreak(),
+            rdf_shacl_description.TokenText("else"),
+        ]
+
+        self.assertTrue(
+            tokens_are_equal(expected, got), f"Expected {expected!r}, got {got!r}"
+        )
+
+    def test_consecutive_paragraph_breaks(self) -> None:
+        got = rdf_shacl_description.without_redundant_breaks(
+            [
+                rdf_shacl_description.TokenText("something"),
+                rdf_shacl_description.TokenParagraphBreak(),
+                rdf_shacl_description.TokenParagraphBreak(),
+                rdf_shacl_description.TokenText("else"),
+            ]
+        )
+
+        expected = [
+            rdf_shacl_description.TokenText("something"),
+            rdf_shacl_description.TokenParagraphBreak(),
+            rdf_shacl_description.TokenText("else"),
+        ]
+
+        self.assertTrue(
+            tokens_are_equal(expected, got), f"Expected {expected!r}, got {got!r}"
+        )
+
+    def test_trailing_breaks(self) -> None:
+        got = rdf_shacl_description.without_redundant_breaks(
+            [
+                rdf_shacl_description.TokenText("something"),
+                rdf_shacl_description.TokenParagraphBreak(),
+                rdf_shacl_description.TokenLineBreak(),
+            ]
+        )
+
+        expected = [rdf_shacl_description.TokenText("something")]
+
+        self.assertTrue(
+            tokens_are_equal(expected, got), f"Expected {expected!r}, got {got!r}"
+        )
+
+    def test_all_breaks(self) -> None:
+        got = rdf_shacl_description.without_redundant_breaks(
+            [
+                rdf_shacl_description.TokenParagraphBreak(),
+                rdf_shacl_description.TokenLineBreak(),
+            ]
+        )
+
+        expected = []  # type: List[rdf_shacl_description.Token]
+
+        self.assertTrue(
+            tokens_are_equal(expected, got), f"Expected {expected!r}, got {got!r}"
+        )
+
+    def test_regression_on_skipped_tokens(self) -> None:
+        # This is an actual bug that caused unexpected cut-off of the tokens.
+        tokens = [
+            rdf_shacl_description.TokenText("An element that is referable by its "),
+            rdf_shacl_description.TokenText("'idShort'"),
+            rdf_shacl_description.TokenText("."),
+            rdf_shacl_description.TokenParagraphBreak(),
+            rdf_shacl_description.TokenText("Something."),
+            rdf_shacl_description.TokenParagraphBreak(),
+        ]  # type: List[rdf_shacl_description.TokenUnion]
+
+        got = rdf_shacl_description.without_redundant_breaks(tokens)
+
+        expected = [
+            rdf_shacl_description.TokenText("An element that is referable by its "),
+            rdf_shacl_description.TokenText("'idShort'"),
+            rdf_shacl_description.TokenText("."),
+            rdf_shacl_description.TokenParagraphBreak(),
+            rdf_shacl_description.TokenText("Something."),
+        ]
+
+        self.assertTrue(
+            tokens_are_equal(expected, got), f"Expected {expected!r}, got {got!r}"
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()