aas-core-codegen 0.0.24__tar.gz → 0.0.25__tar.gz

{aas_core_codegen-0.0.24/aas_core_codegen.egg-info → aas_core_codegen-0.0.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aas-core-codegen
-Version: 0.0.24
+Version: 0.0.25
 Summary: Generate implementations and schemas based on an AAS meta-model.
 Author-email: Marko Ristin <marko@ristin.ch>, Nico Braunisch <nico.braunisch@tu-dresden.de>
 License: MIT

{aas_core_codegen-0.0.24 → aas_core_codegen-0.0.25}/aas_core_codegen/__init__.py

@@ -1,6 +1,6 @@
 """Generate implementations and schemas based on an AAS meta-model."""
 
-__version__ = "0.0.24"
+__version__ = "0.0.25"
 __author__ = "Marko Ristin, Nico Braunisch"
 __license__ = "License :: OSI Approved :: MIT License"
 __status__ = "Production/Stable"

{aas_core_codegen-0.0.24 → aas_core_codegen-0.0.25}/aas_core_codegen/typescript/main.py

@@ -182,6 +182,15 @@ def execute(context: run.Context, stdout: TextIO, stderr: TextIO) -> int:
                 None,
             ),
         ),
+        (
+            test_rel_path / "jsonization.common.spec.ts",
+            lambda: (
+                typescript_tests.generate_jsonization_common_spec(
+                    symbol_table=verified_ir_table,
+                ),
+                None,
+            ),
+        ),
         (
             test_rel_path / "jsonization.enums.spec.ts",
             lambda: (
@@ -200,6 +209,33 @@ def execute(context: run.Context, stdout: TextIO, stderr: TextIO) -> int:
                 None,
             ),
         ),
+        (
+            test_rel_path / "jsonization.negative.spec.ts",
+            lambda: (
+                typescript_tests.generate_jsonization_negative_spec(
+                    symbol_table=verified_ir_table,
+                ),
+                None,
+            ),
+        ),
+        (
+            test_rel_path / "stringification.enums.spec.ts",
+            lambda: (
+                typescript_tests.generate_stringification_enums_spec(
+                    symbol_table=verified_ir_table,
+                ),
+                None,
+            ),
+        ),
+        (
+            test_rel_path / "verification.spec.ts",
+            lambda: (
+                typescript_tests.generate_verification_spec(
+                    symbol_table=verified_ir_table,
+                ),
+                None,
+            ),
+        ),
         (
             test_rel_path / "xmlization.concreteClasses.spec.ts",
             lambda: (
@@ -209,6 +245,13 @@ def execute(context: run.Context, stdout: TextIO, stderr: TextIO) -> int:
                 None,
             ),
         ),
+        (
+            test_rel_path / "xmlization.basic.spec.ts",
+            lambda: (
+                typescript_tests.generate_xmlization_basic_spec(),
+                None,
+            ),
+        ),
         (
             test_rel_path / "xmlization.common.spec.ts",
             lambda: (

{aas_core_codegen-0.0.24 → aas_core_codegen-0.0.25}/aas_core_codegen/typescript/tests/__init__.py

@@ -6,10 +6,14 @@ from aas_core_codegen.typescript.tests import (
     _generate_common_base64url_spec,
     _generate_common_jsonization,
     _generate_common_xmlization,
+    _generate_jsonization_common_spec,
     _generate_jsonization_concrete_classes_spec,
     _generate_jsonization_enums_spec,
     _generate_jsonization_interfaces_spec,
+    _generate_jsonization_negative_spec,
+    _generate_stringification_enums_spec,
     _generate_xmlization_concrete_classes_spec,
+    _generate_xmlization_basic_spec,
     _generate_xmlization_common_spec,
     _generate_xmlization_enums_spec,
     _generate_xmlization_interfaces_spec,
@@ -22,6 +26,7 @@ from aas_core_codegen.typescript.tests import (
     _generate_types_over_x_or_empty_spec,
     _generate_types_type_matches_spec,
     _generate_types_x_or_default_spec,
+    _generate_verification_spec,
 )
 
 generate_common = _generate_common.generate
@@ -29,14 +34,18 @@ generate_common_base64_spec = _generate_common_base64_spec.generate
 generate_common_base64url_spec = _generate_common_base64url_spec.generate
 generate_common_jsonization = _generate_common_jsonization.generate
 generate_common_xmlization = _generate_common_xmlization.generate
+generate_jsonization_common_spec = _generate_jsonization_common_spec.generate
 generate_jsonization_concrete_classes_spec = (
     _generate_jsonization_concrete_classes_spec.generate
 )
 generate_jsonization_enums_spec = _generate_jsonization_enums_spec.generate
 generate_jsonization_interfaces_spec = _generate_jsonization_interfaces_spec.generate
+generate_jsonization_negative_spec = _generate_jsonization_negative_spec.generate
+generate_stringification_enums_spec = _generate_stringification_enums_spec.generate
 generate_xmlization_concrete_classes_spec = (
     _generate_xmlization_concrete_classes_spec.generate
 )
+generate_xmlization_basic_spec = _generate_xmlization_basic_spec.generate
 generate_xmlization_common_spec = _generate_xmlization_common_spec.generate
 generate_xmlization_enums_spec = _generate_xmlization_enums_spec.generate
 generate_xmlization_interfaces_spec = _generate_xmlization_interfaces_spec.generate
@@ -51,3 +60,4 @@ generate_types_over_enum_spec = _generate_types_over_enum_spec.generate
 generate_types_over_x_or_empty_spec = _generate_types_over_x_or_empty_spec.generate
 generate_types_type_matches_spec = _generate_types_type_matches_spec.generate
 generate_types_x_or_default_spec = _generate_types_x_or_default_spec.generate
+generate_verification_spec = _generate_verification_spec.generate

aas_core_codegen-0.0.25/aas_core_codegen/typescript/tests/_generate_jsonization_common_spec.py

@@ -0,0 +1,74 @@
+"""Generate code to execute all common JSONization loader functions once."""
+
+import io
+from typing import List
+
+from icontract import ensure
+
+from aas_core_codegen import intermediate
+from aas_core_codegen.common import Identifier, Stripped
+from aas_core_codegen.typescript import (
+    common as typescript_common,
+    naming as typescript_naming,
+)
+from aas_core_codegen.typescript.common import INDENT as I
+
+
+# fmt: off
+@ensure(
+    lambda result: result.endswith('\n'),
+    "Trailing newline mandatory for valid end-of-files"
+)
+# fmt: on
+def generate(symbol_table: intermediate.SymbolTable) -> str:
+    """Generate code to execute all common JSONization loader functions once."""
+    blocks = [
+        Stripped(
+            """\
+/**
+ * Execute all common JSONization loader helpers once.
+ */"""
+        ),
+        typescript_common.WARNING,
+        Stripped(
+            """\
+import * as TestCommonJsonization from "./commonJsonization";"""
+        ),
+    ]  # type: List[Stripped]
+
+    for concrete_cls in symbol_table.concrete_classes:
+        load_maximal_name = typescript_naming.function_name(
+            Identifier(f"load_maximal_{concrete_cls.name}")
+        )
+        load_minimal_name = typescript_naming.function_name(
+            Identifier(f"load_minimal_{concrete_cls.name}")
+        )
+        cls_name_typescript = typescript_naming.class_name(concrete_cls.name)
+
+        blocks.append(
+            Stripped(
+                f"""\
+test("commonJsonization loaders for {cls_name_typescript}", () => {{
+{I}expect(TestCommonJsonization.{load_minimal_name}()).not.toBeNull();
+{I}expect(TestCommonJsonization.{load_maximal_name}()).not.toBeNull();
+}});"""
+            )
+        )
+
+    blocks.append(typescript_common.WARNING)
+
+    writer = io.StringIO()
+    for i, block in enumerate(blocks):
+        if i > 0:
+            writer.write("\n\n")
+
+        writer.write(block)
+
+    writer.write("\n")
+
+    return writer.getvalue()
+
+
+assert generate.__doc__ is not None
+assert __doc__ is not None
+assert generate.__doc__.strip().startswith(__doc__.strip())

{aas_core_codegen-0.0.24 → aas_core_codegen-0.0.25}/aas_core_codegen/typescript/tests/_generate_jsonization_enums_spec.py

@@ -47,17 +47,17 @@ import * as AasTypes from "../src/types";"""
             len(enumeration.literals) > 0
         ), f"Unexpected enumeration without literals: {enumeration.name}"
 
-        literal = enumeration.literals[0]
-        literal_name_typescript = typescript_naming.enum_literal_name(literal.name)
-
         deserialization_function = typescript_naming.function_name(
             Identifier(f"{enumeration.name}_from_jsonable")
         )
 
-        blocks.append(
-            Stripped(
-                f"""\
-test("{enum_name_typescript} round-trip OK", () => {{
+        for literal in enumeration.literals:
+            literal_name_typescript = typescript_naming.enum_literal_name(literal.name)
+
+            blocks.append(
+                Stripped(
+                    f"""\
+test("{enum_name_typescript} deserializes {literal_name_typescript} OK", () => {{
 {I}const jsonable = {typescript_common.string_literal(literal.value)};
 
 {I}const literalOrError = AasJsonization.{deserialization_function}(
@@ -65,14 +65,14 @@ test("{enum_name_typescript} round-trip OK", () => {{
 {I});
 
 {I}expect(literalOrError.error).toBeNull();
-{I}const literal = literalOrError.mustValue();
+{I}const parsedLiteral = literalOrError.mustValue();
 
-{I}expect(literal).toStrictEqual(
+{I}expect(parsedLiteral).toStrictEqual(
 {II}AasTypes.{enum_name_typescript}.{literal_name_typescript}
 {I});
 }});"""
+                )
             )
-        )
 
         literal_value_set = set(literal.value for literal in enumeration.literals)
         invalid_literal_value = "invalid-literal"

aas_core_codegen-0.0.25/aas_core_codegen/typescript/tests/_generate_jsonization_negative_spec.py

@@ -0,0 +1,316 @@
+"""Generate code for targeted negative JSONization tests."""
+
+import io
+from typing import List, Optional, Tuple
+
+from icontract import ensure
+
+from aas_core_codegen import intermediate, naming
+from aas_core_codegen.common import Identifier, Stripped
+from aas_core_codegen.typescript import common as typescript_common
+from aas_core_codegen.typescript import naming as typescript_naming
+from aas_core_codegen.typescript.common import INDENT as I
+
+
+def _first_concrete_class(
+    symbol_table: intermediate.SymbolTable,
+) -> Optional[intermediate.ConcreteClass]:
+    """Select the first concrete class, if any."""
+    for concrete_cls in symbol_table.concrete_classes:
+        return concrete_cls
+
+    return None
+
+
+def _first_required_property_candidate(
+    symbol_table: intermediate.SymbolTable,
+) -> Optional[Tuple[intermediate.ConcreteClass, intermediate.Property]]:
+    """Find the first required property among all concrete classes."""
+    for concrete_cls in symbol_table.concrete_classes:
+        for prop in concrete_cls.properties:
+            if not isinstance(
+                prop.type_annotation, intermediate.OptionalTypeAnnotation
+            ):
+                return concrete_cls, prop
+
+    return None
+
+
+def _first_property_for_type_mismatch_candidate(
+    symbol_table: intermediate.SymbolTable,
+) -> Optional[Tuple[intermediate.ConcreteClass, intermediate.Property, str]]:
+    """Find a property where replacing with an object should fail parsing."""
+    for concrete_cls in symbol_table.concrete_classes:
+        for prop in concrete_cls.properties:
+            type_anno = intermediate.beneath_optional(prop.type_annotation)
+
+            if isinstance(type_anno, intermediate.PrimitiveTypeAnnotation):
+                file_name = (
+                    "minimal.json"
+                    if not isinstance(
+                        prop.type_annotation,
+                        intermediate.OptionalTypeAnnotation,
+                    )
+                    else "maximal.json"
+                )
+                return concrete_cls, prop, file_name
+
+            if isinstance(type_anno, intermediate.ListTypeAnnotation):
+                file_name = (
+                    "minimal.json"
+                    if not isinstance(
+                        prop.type_annotation,
+                        intermediate.OptionalTypeAnnotation,
+                    )
+                    else "maximal.json"
+                )
+                return concrete_cls, prop, file_name
+
+            if isinstance(type_anno, intermediate.OurTypeAnnotation):
+                if isinstance(
+                    type_anno.our_type,
+                    (intermediate.AbstractClass, intermediate.ConcreteClass),
+                ):
+                    continue
+
+                file_name = (
+                    "minimal.json"
+                    if not isinstance(
+                        prop.type_annotation,
+                        intermediate.OptionalTypeAnnotation,
+                    )
+                    else "maximal.json"
+                )
+                return concrete_cls, prop, file_name
+
+    return None
+
+
+def _first_nested_class_dispatch_candidate(
+    symbol_table: intermediate.SymbolTable,
+) -> Optional[Tuple[intermediate.ConcreteClass, intermediate.Property]]:
+    """Find a property parsed through class dispatch based on ``modelType``."""
+    for concrete_cls in symbol_table.concrete_classes:
+        for prop in concrete_cls.properties:
+            type_anno = intermediate.beneath_optional(prop.type_annotation)
+            if not isinstance(type_anno, intermediate.OurTypeAnnotation):
+                continue
+
+            if not isinstance(
+                type_anno.our_type,
+                (intermediate.AbstractClass, intermediate.ConcreteClass),
+            ):
+                continue
+
+            if (
+                isinstance(type_anno.our_type, intermediate.ConcreteClass)
+                and len(type_anno.our_type.concrete_descendants) == 0
+            ):
+                continue
+
+            return concrete_cls, prop
+
+    return None
+
+
+# fmt: off
+@ensure(
+    lambda result: result.endswith('\n'),
+    "Trailing newline mandatory for valid end-of-files"
+)
+# fmt: on
+def generate(symbol_table: intermediate.SymbolTable) -> str:
+    """Generate code for targeted negative JSONization tests."""
+    blocks = [
+        Stripped(
+            """\
+/**
+ * Test failure modes in JSON parsing to exercise defensive branches.
+ */"""
+        ),
+        typescript_common.WARNING,
+        Stripped(
+            """\
+import * as path from "path";
+
+import * as AasJsonization from "../src/jsonization";
+
+import * as TestCommon from "./common";
+
+function readExpectedJson(
+    classJsonName: string,
+    fileName: "minimal.json" | "maximal.json"
+): AasJsonization.JsonValue {
+  const pth = path.join(TestCommon.TEST_DATA_DIR, "Json", "Expected", classJsonName, fileName);
+  return TestCommon.readJsonFromFileSync(pth);
+}
+
+function mustBeJsonObject(jsonable: AasJsonization.JsonValue): AasJsonization.JsonObject {
+  if (
+    typeof jsonable !== "object" ||
+    jsonable === null ||
+    typeof jsonable[Symbol.iterator] === "function"
+  ) {
+    throw new Error(`Expected a JSON object, but got: ${JSON.stringify(jsonable)}`);
+  }
+
+  return <AasJsonization.JsonObject>jsonable;
+}"""
+        ),
+    ]  # type: List[Stripped]
+
+    first_cls = _first_concrete_class(symbol_table)
+    if first_cls is not None:
+        deserialization_function = typescript_naming.function_name(
+            Identifier(f"{first_cls.name}_from_jsonable")
+        )
+
+        blocks.append(
+            Stripped(
+                f"""\
+test("{typescript_naming.class_name(first_cls.name)} deserialization fails on non-object", () => {{
+{I}const jsonable = "This is not a JSON object.";
+
+{I}const instanceOrError = AasJsonization.{deserialization_function}(
+{I}{I}jsonable
+{I});
+
+{I}expect(instanceOrError.error).not.toBeNull();
+}});"""
+            )
+        )
+
+    required_property_candidate = _first_required_property_candidate(symbol_table)
+    if required_property_candidate is not None:
+        required_cls, required_prop = required_property_candidate
+        required_cls_name_json_literal = typescript_common.string_literal(
+            naming.json_model_type(required_cls.name)
+        )
+        required_deserialization_function = typescript_naming.function_name(
+            Identifier(f"{required_cls.name}_from_jsonable")
+        )
+        required_property_name_literal = typescript_common.string_literal(
+            naming.json_property(required_prop.name)
+        )
+
+        blocks.append(
+            Stripped(
+                f"""\
+test("{typescript_naming.class_name(required_cls.name)} deserialization fails with missing required property", () => {{
+{I}const jsonable = readExpectedJson(
+{I}{I}{required_cls_name_json_literal},
+{I}{I}"minimal.json"
+{I});
+
+{I}const jsonObject = {{ ...mustBeJsonObject(jsonable) }};
+{I}delete jsonObject[{required_property_name_literal}];
+
+{I}const instanceOrError = AasJsonization.{required_deserialization_function}(
+{I}{I}jsonObject
+{I});
+
+{I}expect(instanceOrError.error).not.toBeNull();
+}});"""
+            )
+        )
+
+    type_mismatch_candidate = _first_property_for_type_mismatch_candidate(symbol_table)
+    if type_mismatch_candidate is not None:
+        mismatch_cls, mismatch_prop, mismatch_file_name = type_mismatch_candidate
+        mismatch_cls_name_json_literal = typescript_common.string_literal(
+            naming.json_model_type(mismatch_cls.name)
+        )
+        mismatch_deserialization_function = typescript_naming.function_name(
+            Identifier(f"{mismatch_cls.name}_from_jsonable")
+        )
+        mismatch_property_name_literal = typescript_common.string_literal(
+            naming.json_property(mismatch_prop.name)
+        )
+
+        blocks.append(
+            Stripped(
+                f"""\
+test("{typescript_naming.class_name(mismatch_cls.name)} deserialization fails with property type mismatch", () => {{
+{I}const jsonable = readExpectedJson(
+{I}{I}{mismatch_cls_name_json_literal},
+{I}{I}{typescript_common.string_literal(mismatch_file_name)}
+{I});
+
+{I}const jsonObject = {{ ...mustBeJsonObject(jsonable) }};
+{I}jsonObject[{mismatch_property_name_literal}] = {{ definitely: "unexpected-object" }};
+
+{I}const instanceOrError = AasJsonization.{mismatch_deserialization_function}(
+{I}{I}jsonObject
+{I});
+
+{I}expect(instanceOrError.error).not.toBeNull();
+}});"""
+            )
+        )
+
+    nested_dispatch_candidate = _first_nested_class_dispatch_candidate(symbol_table)
+    if nested_dispatch_candidate is not None:
+        nested_cls, nested_prop = nested_dispatch_candidate
+        nested_cls_name_json_literal = typescript_common.string_literal(
+            naming.json_model_type(nested_cls.name)
+        )
+        nested_deserialization_function = typescript_naming.function_name(
+            Identifier(f"{nested_cls.name}_from_jsonable")
+        )
+        nested_property_name_literal = typescript_common.string_literal(
+            naming.json_property(nested_prop.name)
+        )
+        model_type_property_name_literal = typescript_common.string_literal(
+            naming.json_property(Identifier("model_type"))
+        )
+
+        blocks.append(
+            Stripped(
+                f"""\
+test("{typescript_naming.class_name(nested_cls.name)} deserialization fails with invalid nested modelType", () => {{
+{I}const jsonable = readExpectedJson(
+{I}{I}{nested_cls_name_json_literal},
+{I}{I}"maximal.json"
+{I});
+
+{I}const jsonObject = {{ ...mustBeJsonObject(jsonable) }};
+{I}const nestedValue = jsonObject[{nested_property_name_literal}];
+
+{I}if (
+{I}{I}typeof nestedValue !== "object" ||
+{I}{I}nestedValue === null ||
+{I}{I}typeof nestedValue[Symbol.iterator] === "function"
+{I}) {{
+{I}{I}throw new Error("Expected nested class JSON object to be present in maximal example.");
+{I}}}
+
+{I}const nestedObject = {{ ...<AasJsonization.JsonObject>nestedValue }};
+{I}nestedObject[{model_type_property_name_literal}] = "DefinitelyNotAModelType";
+{I}jsonObject[{nested_property_name_literal}] = nestedObject;
+
+{I}const instanceOrError = AasJsonization.{nested_deserialization_function}(
+{I}{I}jsonObject
+{I});
+
+{I}expect(instanceOrError.error).not.toBeNull();
+}});"""
+            )
+        )
+
+    blocks.append(typescript_common.WARNING)
+
+    writer = io.StringIO()
+    for i, block in enumerate(blocks):
+        if i > 0:
+            writer.write("\n\n")
+
+        writer.write(block)
+
+    writer.write("\n")
+
+    return writer.getvalue()
+
+
+assert generate.__doc__ is not None
+assert __doc__ is not None
+assert generate.__doc__.strip().startswith(__doc__.strip())

aas_core_codegen-0.0.25/aas_core_codegen/typescript/tests/_generate_stringification_enums_spec.py

@@ -0,0 +1,121 @@
+"""Generate code to test stringification of enumerations."""
+
+import io
+from typing import List
+
+from icontract import ensure
+
+from aas_core_codegen import intermediate
+from aas_core_codegen.common import Identifier, Stripped
+from aas_core_codegen.typescript import (
+    common as typescript_common,
+    naming as typescript_naming,
+)
+from aas_core_codegen.typescript.common import INDENT as I
+
+
+# fmt: off
+@ensure(
+    lambda result: result.endswith('\n'),
+    "Trailing newline mandatory for valid end-of-files"
+)
+# fmt: on
+def generate(symbol_table: intermediate.SymbolTable) -> str:
+    """Generate code to test stringification of enumerations."""
+    blocks = [
+        Stripped(
+            """\
+/**
+ * Test string de/serialization of enumeration literals.
+ */"""
+        ),
+        typescript_common.WARNING,
+        Stripped(
+            """\
+import * as AasStringification from "../src/stringification";
+import * as AasTypes from "../src/types";"""
+        ),
+    ]  # type: List[Stripped]
+
+    for enumeration in symbol_table.enumerations:
+        enum_name_typescript = typescript_naming.enum_name(enumeration.name)
+
+        from_str_name = typescript_naming.function_name(
+            Identifier(f"{enumeration.name}_from_string")
+        )
+        to_str_name = typescript_naming.function_name(
+            Identifier(f"{enumeration.name}_to_string")
+        )
+        must_to_str_name = typescript_naming.function_name(
+            Identifier(f"must_{enumeration.name}_to_string")
+        )
+
+        for literal in enumeration.literals:
+            literal_name_typescript = typescript_naming.enum_literal_name(literal.name)
+            literal_value_literal = typescript_common.string_literal(literal.value)
+
+            blocks.append(
+                Stripped(
+                    f"""\
+test("{enum_name_typescript} stringification round-trip {literal_name_typescript}", () => {{
+{I}const literal = AasTypes.{enum_name_typescript}.{literal_name_typescript};
+
+{I}const text = AasStringification.{must_to_str_name}(literal);
+{I}expect(text).toStrictEqual({literal_value_literal});
+
+{I}const nullableText = AasStringification.{to_str_name}(literal);
+{I}expect(nullableText).toStrictEqual({literal_value_literal});
+
+{I}const parsed = AasStringification.{from_str_name}(text);
+{I}expect(parsed).toStrictEqual(literal);
+}});"""
+                )
+            )
+
+        literal_value_set = set(literal.value for literal in enumeration.literals)
+        invalid_literal_value = "invalid-literal"
+        while invalid_literal_value in literal_value_set:
+            invalid_literal_value = f"very-{invalid_literal_value}"
+
+        blocks.append(
+            Stripped(
+                f"""\
+test("{enum_name_typescript} from invalid string", () => {{
+{I}const parsed = AasStringification.{from_str_name}(
+{I}{I}{typescript_common.string_literal(invalid_literal_value)}
+{I});
+
+{I}expect(parsed).toBeNull();
+}});"""
+            )
+        )
+
+        blocks.append(
+            Stripped(
+                f"""\
+test("{enum_name_typescript} invalid literal to string", () => {{
+{I}// The number 9007199254740991 is the maximum safe integer.
+{I}const invalidLiteral = <AasTypes.{enum_name_typescript}>9007199254740991;
+
+{I}expect(AasStringification.{to_str_name}(invalidLiteral)).toBeNull();
+{I}expect(() => AasStringification.{must_to_str_name}(invalidLiteral)).toThrow();
+}});"""
+            )
+        )
+
+    blocks.append(typescript_common.WARNING)
+
+    writer = io.StringIO()
+    for i, block in enumerate(blocks):
+        if i > 0:
+            writer.write("\n\n")
+
+        writer.write(block)
+
+    writer.write("\n")
+
+    return writer.getvalue()
+
+
+assert generate.__doc__ is not None
+assert generate.__doc__.strip().startswith(__doc__.strip())