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

dev/tests/rdf_shacl/test_main.py

@@ -0,0 +1,194 @@
+# pylint: disable=missing-docstring
+
+import contextlib
+import io
+import os
+import pathlib
+import tempfile
+import unittest
+
+import aas_core_codegen.main
+
+import tests.common
+
+REPO_DIR = pathlib.Path(os.path.realpath(__file__)).parent.parent.parent.parent
+
+
+class Test_against_recorded(unittest.TestCase):
+    def test_against_expected_meta_models(self) -> None:
+        base_case_dir = (
+            REPO_DIR / "dev" / "test_data" / "rdf_shacl" / "test_main" / "expected"
+        )
+
+        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.RDF_SHACL,
+                    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("rdf-ontology.ttl"),
+                    pathlib.Path("shacl-schema.ttl"),
+                ]:
+                    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(
+                            data=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.",
+                        )
+
+    def test_against_unexpected_meta_models(self) -> None:
+        test_cases = tests.common.test_cases_from_base_case_dir(
+            base_case_dir=(
+                REPO_DIR
+                / "dev"
+                / "test_data"
+                / "rdf_shacl"
+                / "test_main"
+                / "unexpected"
+            )
+        )
+
+        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.RDF_SHACL,
+                    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 stderr on unexpected models, but got nothing "
+                        f"for the test case {test_case.case_dir}"
+                    )
+
+                self.assertNotEqual(
+                    0,
+                    return_code,
+                    f"Expected non-zero return code "
+                    f"on the unexpected model {test_case.case_dir}",
+                )
+
+                stderr_pth = expected_output_dir / "stderr.txt"
+
+                normalized_stderr = stderr.getvalue().replace(
+                    str(test_case.model_path), f"<{test_case.model_path.name}>"
+                )
+
+                if tests.common.RERECORD:
+                    stderr_pth.write_text(normalized_stderr, encoding="utf-8")
+                else:
+                    # NOTE (mristin, 2023-03-08):
+                    # We need to see the full diff on the remote CI server. Otherwise,
+                    # we are completely in the dark why this test fails there. The test
+                    # passed locally, so it was very hard to debug.
+                    self.maxDiff = None
+
+                    self.assertEqual(
+                        normalized_stderr,
+                        stderr_pth.read_text(encoding="utf-8"),
+                        stderr_pth,
+                    )
+
+
+if __name__ == "__main__":
+    unittest.main()

dev/tests/smoke/test_main.py

@@ -0,0 +1,83 @@
+# pylint: disable=missing-module-docstring
+# pylint: disable=missing-class-docstring
+# pylint: disable=missing-function-docstring
+
+import io
+import os
+import pathlib
+import unittest
+
+from aas_core_codegen.smoke import main as smoke_main
+
+import tests.common
+
+
+class Test_against_recorded(unittest.TestCase):
+    def test_cases(self) -> None:
+        repo_dir = pathlib.Path(os.path.realpath(__file__)).parent.parent.parent.parent
+
+        parent_case_dir = repo_dir / "dev" / "test_data" / "smoke" / "test_main"
+        assert parent_case_dir.exists() and parent_case_dir.is_dir(), parent_case_dir
+
+        expected_dir = parent_case_dir / "expected"
+
+        model_paths_of_the_expected = sorted(
+            list(expected_dir.glob("**/*.py"))
+            + list(tests.common.REAL_META_MODEL_PATHS)
+        )
+
+        for model_pth in model_paths_of_the_expected:
+            assert model_pth.is_file(), f"{model_pth=}"
+
+            stderr = io.StringIO()
+            return_code = smoke_main.execute(model_path=model_pth, stderr=stderr)
+            if return_code != 0:
+                parts = [
+                    f"Unexpected non-zero return code from the smoke script "
+                    f"on {model_pth}: {return_code}"
+                ]
+                if stderr.getvalue():
+                    parts.append(f"The captured STDERR was:\n{stderr.getvalue()}")
+
+                raise AssertionError("\n\n".join(parts))
+
+        unexpected_dir = parent_case_dir / "unexpected"
+
+        for model_pth in sorted(unexpected_dir.glob("**/*.py")):
+            stderr = io.StringIO()
+
+            return_code = smoke_main.execute(model_path=model_pth, stderr=stderr)
+
+            if return_code == 0:
+                parts = [
+                    f"Unexpected zero return code from the smoke script "
+                    f"on {model_pth}: {return_code}"
+                ]
+                if stderr.getvalue():
+                    parts.append(f"The captured STDERR was:\n{stderr.getvalue()}")
+
+                raise AssertionError("\n\n".join(parts))
+
+            if stderr.getvalue() == "":
+                raise AssertionError(
+                    f"Unexpected no STDERR from the smoke script on {model_pth}"
+                )
+
+            stderr_pth = model_pth.parent / "expected_stderr.txt"
+
+            normalized_stderr = stderr.getvalue().replace(
+                str(model_pth), f"<{model_pth.name}>"
+            )
+
+            if tests.common.RERECORD:
+                stderr_pth.write_text(normalized_stderr, encoding="utf-8")
+            else:
+                self.assertEqual(
+                    normalized_stderr,
+                    stderr_pth.read_text(encoding="utf-8"),
+                    stderr_pth,
+                )
+
+
+if __name__ == "__main__":
+    unittest.main()

dev/tests/test_common.py

@@ -0,0 +1,94 @@
+# pylint: disable=missing-docstring
+
+import unittest
+
+import aas_core_codegen.common
+
+
+class Test_wrap_text_into_lines(unittest.TestCase):
+    def test_empty(self) -> None:
+        got = aas_core_codegen.common.wrap_text_into_lines(text="")
+
+        self.assertListEqual([""], got)
+
+    def test_short_word(self) -> None:
+        got = aas_core_codegen.common.wrap_text_into_lines(text="something short")
+
+        self.assertListEqual(["something short"], got)
+
+    # noinspection SpellCheckingInspection
+    def test_normal_text(self) -> None:
+        text = (
+            "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, "
+            "sed diam nonumy eirmod tempor invidunt ut labore et dolore magna "
+            "aliquyam erat, sed diam voluptua. At vero eos et accusam et "
+            "justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea "
+            "takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit "
+            "amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt "
+            "ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos "
+            "et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, "
+            "no sea takimata sanctus est Lorem ipsum dolor sit amet."
+        )
+
+        expected = [
+            "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, ",
+            "sed diam nonumy eirmod tempor invidunt ut labore et dolore ",
+            "magna aliquyam erat, sed diam voluptua. At vero eos et ",
+            "accusam et justo duo dolores et ea rebum. Stet clita kasd ",
+            "gubergren, no sea takimata sanctus est Lorem ipsum dolor ",
+            "sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing ",
+            "elitr, sed diam nonumy eirmod tempor invidunt ut labore et ",
+            "dolore magna aliquyam erat, sed diam voluptua. At vero eos ",
+            "et accusam et justo duo dolores et ea rebum. Stet clita ",
+            "kasd gubergren, no sea takimata sanctus est Lorem ipsum ",
+            "dolor sit amet.",
+        ]
+
+        got = aas_core_codegen.common.wrap_text_into_lines(text=text)
+        self.assertListEqual(expected, got)
+
+    def test_very_long_word(self) -> None:
+        word = "1234567890" * 90
+
+        text = f"prefix {word} suffix"
+
+        expected = ["prefix ", f"{word} ", "suffix"]
+
+        got = aas_core_codegen.common.wrap_text_into_lines(text=text)
+        self.assertListEqual(expected, got)
+
+    def test_article_kept_on_the_same_line(self) -> None:
+        somethings = " ".join(["a something"] * 10)
+
+        text = f"prefix {somethings} suffix"
+
+        expected = [
+            "prefix a something a something a something a something ",
+            "a something a something a something a something a something ",
+            "a something suffix",
+        ]
+
+        got = aas_core_codegen.common.wrap_text_into_lines(text=text)
+        self.assertListEqual(expected, got)
+
+    def test_only_articles(self) -> None:
+        text = " ".join(["a an the"] * 60)
+        expected = [
+            "a an the a an the a an the a an the a an the a an the a an ",
+            "the a an the a an the a an the a an the a an the a an the a ",
+            "an the a an the a an the a an the a an the a an the a an ",
+            "the a an the a an the a an the a an the a an the a an the a ",
+            "an the a an the a an the a an the a an the a an the a an ",
+            "the a an the a an the a an the a an the a an the a an the a ",
+            "an the a an the a an the a an the a an the a an the a an ",
+            "the a an the a an the a an the a an the a an the a an the a ",
+            "an the a an the a an the a an the a an the a an the a an ",
+            "the a an the",
+        ]
+
+        got = aas_core_codegen.common.wrap_text_into_lines(text=text)
+        self.assertListEqual(expected, got)
+
+
+if __name__ == "__main__":
+    unittest.main()

dev/tests/typescript/test_common.py

@@ -0,0 +1,108 @@
+# pylint: disable=missing-docstring
+
+import unittest
+
+import aas_core_codegen.typescript.common as typescript_common
+
+
+class TestStringLiteral(unittest.TestCase):
+    def test_empty(self) -> None:
+        self.assertEqual('""', typescript_common.string_literal(""))
+
+    def test_no_quotes(self) -> None:
+        self.assertEqual('"x"', typescript_common.string_literal("x"))
+
+    def test_double_quotes_but_no_single_quotes(self) -> None:
+        self.assertEqual('"a\\"b"', typescript_common.string_literal('a"b'))
+
+    def test_single_quotes_but_no_double_quotes(self) -> None:
+        self.assertEqual('"a\'b"', typescript_common.string_literal("a'b"))
+
+    def test_tab(self) -> None:
+        self.assertEqual('"a\\tb"', typescript_common.string_literal("a\tb"))
+
+    def test_unset_in_backticks(self) -> None:
+        self.assertEqual(
+            '"`AAA`"',
+            typescript_common.string_literal("`AAA`", in_backticks=False),
+        )
+
+        self.assertEqual('"`AAA`"', typescript_common.string_literal("`AAA`"))
+
+    def test_dont_escape_quotes_in_backticks(self) -> None:
+        self.assertEqual(
+            '"',
+            typescript_common.string_literal(
+                '"', without_enclosing=True, in_backticks=True
+            ),
+        )
+
+    def test_escape_backticks_and_dollar_signs_in_backticks(self) -> None:
+        self.assertEqual(
+            "\\`$\\${something}",
+            typescript_common.string_literal(
+                "`$${something}", without_enclosing=True, in_backticks=True
+            ),
+        )
+
+
+class TestBytesLiteral(unittest.TestCase):
+    def test_empty(self) -> None:
+        self.assertTupleEqual(
+            ("new Uint8Array()", False), typescript_common.bytes_literal(bytearray(b""))
+        )
+
+    def test_one(self) -> None:
+        self.assertTupleEqual(
+            ("new Uint8Array([0x00])", False),
+            typescript_common.bytes_literal(bytearray(b"\x00")),
+        )
+
+    def test_eight(self) -> None:
+        self.assertTupleEqual(
+            ("new Uint8Array([0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07])", False),
+            typescript_common.bytes_literal(
+                bytearray(b"\x00\x01\x02\x03\x04\x05\x06\x07")
+            ),
+        )
+
+    def test_nine(self) -> None:
+        code, multiline = typescript_common.bytes_literal(
+            bytearray(b"\x00\x01\x02\x03\x04\x05\x06\x07\x08")
+        )
+
+        self.assertEqual(
+            """\
+new Uint8Array(
+  [
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+    0x08
+  ]
+)""",
+            code,
+        )
+        self.assertTrue(multiline)
+
+    def test_sixteen(self) -> None:
+        code, multiline = typescript_common.bytes_literal(
+            bytearray(
+                b"\x00\x01\x02\x03\x04\x05\x06\x07" b"\x08\x09\x10\x11\x12\x13\x14\x15"
+            )
+        )
+
+        self.assertEqual(
+            """\
+new Uint8Array(
+  [
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+    0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15
+  ]
+)""",
+            code,
+        )
+
+        self.assertTrue(multiline)
+
+
+if __name__ == "__main__":
+    unittest.main()

dev/tests/typescript/test_main.py

@@ -0,0 +1,125 @@
+# pylint: disable=missing-docstring
+
+import contextlib
+import io
+import os
+import pathlib
+import tempfile
+import unittest
+
+import aas_core_codegen.main
+
+import tests.common
+
+
+class Test_against_recorded(unittest.TestCase):
+    def test_cases(self) -> None:
+        repo_dir = pathlib.Path(os.path.realpath(__file__)).parent.parent.parent.parent
+
+        parent_case_dir = repo_dir / "dev" / "test_data" / "typescript" / "test_main"
+        assert parent_case_dir.exists() and parent_case_dir.is_dir(), parent_case_dir
+
+        for model_pth in tests.common.REAL_META_MODEL_PATHS:
+            case_dir = parent_case_dir / model_pth.stem
+            assert case_dir.is_dir(), case_dir
+
+            snippets_dir = case_dir / "input/snippets"
+            assert snippets_dir.exists() and snippets_dir.is_dir(), snippets_dir
+
+            expected_output_dir = 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=model_pth,
+                    target=aas_core_codegen.main.Target.TYPESCRIPT,
+                    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("common.ts"),
+                    pathlib.Path("constants.ts"),
+                    pathlib.Path("jsonization.ts"),
+                    pathlib.Path("stringification.ts"),
+                    pathlib.Path("types.ts"),
+                    pathlib.Path("verification.ts"),
+                ]:
+                    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}"
+                        )
+
+                    try:
+                        output = output_pth.read_text(encoding="utf-8")
+                    except Exception as exception:
+                        raise RuntimeError(
+                            f"Failed to read the output from {output_pth}"
+                        ) from exception
+
+                    if tests.common.RERECORD:
+                        expected_pth.write_text(output, encoding="utf-8")
+                    else:
+                        try:
+                            expected_output = expected_pth.read_text(encoding="utf-8")
+                        except Exception as exception:
+                            raise RuntimeError(
+                                f"Failed to read the expected output "
+                                f"from {expected_pth}"
+                            ) from exception
+
+                        self.assertEqual(
+                            expected_output,
+                            output,
+                            f"The files {expected_pth} and {output_pth} do not match.",
+                        )
+
+
+if __name__ == "__main__":
+    unittest.main()