avrotize 2.20.5__tar.gz → 2.21.1__tar.gz

{avrotize-2.20.5 → avrotize-2.21.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: avrotize
-Version: 2.20.5
+Version: 2.21.1
 Summary: Tools to convert from and to Avro Schema from various other schema languages.
 Author-email: Clemens Vasters <clemensv@microsoft.com>
 Requires-Python: >=3.10

{avrotize-2.20.5 → avrotize-2.21.1}/avrotize/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.20.5'
-__version_tuple__ = version_tuple = (2, 20, 5)
+__version__ = version = '2.21.1'
+__version_tuple__ = version_tuple = (2, 21, 1)
 
-__commit_id__ = commit_id = 'g4811363b1'
+__commit_id__ = commit_id = 'g9b9841dd3'

{avrotize-2.20.5 → avrotize-2.21.1}/avrotize/avrotopython/dataclass_core.jinja

@@ -48,7 +48,7 @@ class {{ class_name }}:
     """
     {% for field in fields %}
     {%- set isdate = field.type == "datetime" or field.type == "typing.Optional[datetime.datetime]" %}
-    {{ field.name }}: {{ field.type }}=dataclasses.field(kw_only=True{% if dataclasses_json_annotation %}, metadata=dataclasses_json.config(field_name="{{ field.original_name }}"{%- if isdate -%}, encoder=lambda d: datetime.datetime.isoformat(d) if d else None, decoder=lambda d:datetime.datetime.fromisoformat(d) if d else None, mm_field=fields.DateTime(format='iso'){%- endif -%}){%- endif %})
+    {{ field.name }}: {{ field.type }}=dataclasses.field(kw_only=True{% if dataclasses_json_annotation %}, metadata=dataclasses_json.config(field_name="{{ field.original_name }}"{%- if isdate -%}, encoder=lambda d: d.isoformat() if isinstance(d, datetime.datetime) else d if d else None, decoder=lambda d: datetime.datetime.fromisoformat(d) if isinstance(d, str) else d if d else None, mm_field=fields.DateTime(format='iso'){%- endif -%}){%- endif %})
     {%- endfor %}
     {% if avro_annotation %}
     AvroType: typing.ClassVar[avro.schema.Schema] = avro.schema.make_avsc_object(

{avrotize-2.20.5 → avrotize-2.21.1}/avrotize/avrotopython/test_class.jinja

@@ -12,7 +12,8 @@ from {{ package_name | lower }} import {{ class_name }}
 
 {%- for import_type in import_types if import_type not in ['decimal.Decimal', 'datetime.datetime', 'datetime.date', 'datetime.time', 'datetime.timedelta'] %}
 {%- set import_type_name = 'Test_'+import_type.split('.')[-1] %}
-{%- set import_package_name = 'test_'+'_'.join(import_type.split('.')[:-1]) | lower %}
+{%- set flat_package = '_'.join(import_type.split('.')[:-1]) | lower %}
+{%- set import_package_name = flat_package if flat_package.startswith('test_') else 'test_' + flat_package %}
 
 {%- if import_type.startswith('.') %}
 from .{{ import_package_name }} import {{ import_type_name }}

{avrotize-2.20.5 → avrotize-2.21.1}/avrotize/avrotopython.py

@@ -327,7 +327,8 @@ class AvroToPython:
     def generate_test_class(self, package_name: str, class_name: str, fields: List[Dict[str, str]], import_types: Set[str]) -> None:
         """Generates a unit test class for a Python data class"""
         test_class_name = f"Test_{class_name}"
-        tests_package_name = "test_"+package_name.replace('.', '_').lower()
+        flat_package = package_name.replace('.', '_').lower()
+        tests_package_name = flat_package if flat_package.startswith('test_') else f"test_{flat_package}"
         test_class_definition = process_template(
             "avrotopython/test_class.jinja",
             package_name=package_name,
@@ -348,7 +349,8 @@ class AvroToPython:
     def generate_test_enum(self, package_name: str, class_name: str, symbols: List[str]) -> None:
         """Generates a unit test class for a Python enum"""
         test_class_name = f"Test_{class_name}"
-        tests_package_name = "test_"+package_name.replace('.', '_').lower()
+        flat_package = package_name.replace('.', '_').lower()
+        tests_package_name = flat_package if flat_package.startswith('test_') else f"test_{flat_package}"
         test_class_definition = process_template(
             "avrotopython/test_enum.jinja",
             package_name=package_name,

{avrotize-2.20.5 → avrotize-2.21.1}/avrotize/structuretocsharp.py

@@ -2072,8 +2072,8 @@ class StructureToCSharp:
             if enum_values:
                 for value in enum_values:
                     if isinstance(value, str):
-                        # Convert to PascalCase enum member name
-                        symbol_name = ''.join(word.capitalize() for word in re.split(r'[_\-\s]+', value))
+                        # Convert to PascalCase enum member name - must match generate_enum logic
+                        symbol_name = pascal(str(value).replace('-', '_').replace(' ', '_'))
                         symbols.append(symbol_name)
                     else:
                         # For numeric enums, use Value1, Value2, etc.

{avrotize-2.20.5 → avrotize-2.21.1}/avrotize/structuretogo/go_helpers.jinja

@@ -1,5 +1,10 @@
 package {{ base_package }}
 
+{%- if needs_time_import %}
+
+import "time"
+{%- endif %}
+
 {%- for struct in structs %}
 
 // CreateInstance{{ struct.name }} creates a new instance of {{ struct.name }} with sample data

{avrotize-2.20.5 → avrotize-2.21.1}/avrotize/structuretogo/go_test.jinja

@@ -2,16 +2,16 @@ package {{ base_package }}
 
 import (
     "testing"
-    {%- if json_annotation %}
+    {%- if json_annotation and kind == 'struct' %}
     "encoding/json"
     {%- endif %}
 )
 
 func Test{{ struct_name }}(t *testing.T) {
     {%- if kind == 'struct' %}
+    {%- if json_annotation %}
     instance := CreateInstance{{ struct_name }}()
     
-    {%- if json_annotation %}
     // Test JSON marshaling
     data, err := json.Marshal(&instance)
     if err != nil {
@@ -56,6 +56,10 @@ func Test{{ struct_name }}(t *testing.T) {
     if fromDataGzip == nil {
         t.Fatal("FromData with gzip returned nil")
     }
+    {%- else %}
+    // Basic instance creation test (no JSON serialization without json annotation)
+    instance := CreateInstance{{ struct_name }}()
+    _ = instance // Verify instance creation works
     {%- endif %}
     {%- elif kind == 'enum' %}
     // Test enum values

{avrotize-2.20.5 → avrotize-2.21.1}/avrotize/structuretogo.py

@@ -523,6 +523,10 @@ class StructureToGo:
             v = f'float64({random.uniform(-100, 100)})'
         elif go_type == '[]byte':
             v = '[]byte("' + ''.join(random.choices(string.ascii_letters + string.digits, k=10)) + '")'
+        elif go_type == 'time.Time':
+            v = 'time.Now()'
+        elif go_type == 'time.Duration':
+            v = 'time.Hour'
         elif go_type.startswith('[]'):
             inner_type = go_type[2:]
             v = f'{go_type}{{{self.random_value(inner_type)}}}'
@@ -549,10 +553,15 @@ class StructureToGo:
             'enums': self.enums,
             'base_package': self.base_package,
         }
+        needs_time_import = False
         for struct in context['structs']:
             for field in struct['fields']:
                 if 'value' not in field:
                     field['value'] = self.random_value(field['type'])
+                # Check if time package is needed
+                if 'time.Time' in field['type'] or 'time.Duration' in field['type']:
+                    needs_time_import = True
+        context['needs_time_import'] = needs_time_import
         helpers_file_name = os.path.join(self.output_dir, 'pkg', self.base_package, f"{self.base_package}_helpers.go")
         render_template('structuretogo/go_helpers.jinja', helpers_file_name, **context)
 

{avrotize-2.20.5 → avrotize-2.21.1}/avrotize/structuretojava.py

@@ -384,7 +384,12 @@ class StructureToJava:
             field_count=len(field_names)
         )
         
-        class_definition = class_definition.rstrip() + equals_hashcode + "\n}\n"
+        # Generate createTestInstance() method for testing (only for non-abstract classes)
+        create_test_instance = ''
+        if not is_abstract:
+            create_test_instance = self.generate_create_test_instance_method(class_name, fields, schema_namespace)
+        
+        class_definition = class_definition.rstrip() + create_test_instance + equals_hashcode + "\n}\n"
 
         if write_file:
             self.write_to_file(package, class_name, class_definition)
@@ -455,6 +460,86 @@ class StructureToJava:
             return str(value)
         return f"/* unsupported const value */"
 
+    def get_test_value(self, java_type: str) -> str:
+        """ Get a test value for a Java type """
+        # Handle arrays/lists
+        if java_type.startswith("List<") or java_type.startswith("ArrayList<"):
+            return "new java.util.ArrayList<>()"
+        if java_type.startswith("Map<"):
+            return "new java.util.HashMap<>()"
+        if java_type.endswith("[]"):
+            return f"new {java_type[:-2]}[0]"
+        
+        # Primitive test values
+        test_values = {
+            'String': '"test-string"',
+            'string': '"test-string"',
+            'int': '42',
+            'Integer': '42',
+            'long': '42L',
+            'Long': '42L',
+            'double': '3.14',
+            'Double': '3.14',
+            'float': '3.14f',
+            'Float': '3.14f',
+            'boolean': 'true',
+            'Boolean': 'true',
+            'byte': '(byte)0',
+            'Byte': '(byte)0',
+            'short': '(short)0',
+            'Short': '(short)0',
+            'BigInteger': 'java.math.BigInteger.ZERO',
+            'BigDecimal': 'java.math.BigDecimal.ZERO',
+            'byte[]': 'new byte[0]',
+            'LocalDate': 'java.time.LocalDate.now()',
+            'LocalTime': 'java.time.LocalTime.now()',
+            'Instant': 'java.time.Instant.now()',
+            'Duration': 'java.time.Duration.ZERO',
+            'UUID': 'java.util.UUID.randomUUID()',
+            'URI': 'java.net.URI.create("http://example.com")',
+            'Object': 'new Object()',
+            'void': 'null',
+            'Void': 'null',
+        }
+        
+        if java_type in test_values:
+            return test_values[java_type]
+        
+        # Check if it's a generated type (enum or class)
+        if java_type in self.generated_types_java_package:
+            type_kind = self.generated_types_java_package[java_type]
+            if type_kind == "enum":
+                return f'{java_type}.values()[0]'
+            elif type_kind == "class":
+                return f'{java_type}.createTestInstance()'
+        
+        # Default: try to instantiate
+        return f'new {java_type}()'
+
+    def generate_create_test_instance_method(self, class_name: str, fields: List[Dict], parent_package: str) -> str:
+        """ Generates a static createTestInstance method that creates a fully initialized instance """
+        method = f"\n{INDENT}/**\n{INDENT} * Creates a test instance with all required fields populated\n{INDENT} * @return a fully initialized test instance\n{INDENT} */\n"
+        method += f"{INDENT}public static {class_name} createTestInstance() {{\n"
+        method += f"{INDENT*2}{class_name} instance = new {class_name}();\n"
+        
+        for field in fields:
+            # Skip const fields
+            if field.get('is_const', False):
+                continue
+            
+            field_name = field['name']
+            field_type = field['type']
+            
+            # Get a test value for this field
+            test_value = self.get_test_value(field_type)
+            
+            # Setter name: set{Pascal(field_name)}
+            method += f"{INDENT*2}instance.set{pascal(field_name)}({test_value});\n"
+        
+        method += f"{INDENT*2}return instance;\n"
+        method += f"{INDENT}}}\n"
+        return method
+
     def generate_enum(self, structure_schema: Dict, field_name: str, parent_package: str, write_file: bool) -> JavaType:
         """ Generates a Java enum from JSON Structure enum schema """
         

{avrotize-2.20.5 → avrotize-2.21.1}/avrotize/structuretopython/dataclass_core.jinja

@@ -69,7 +69,7 @@ class {{ class_name }}{% if base_class or is_abstract %}({% if base_class %}{{ b
     {% endif %}
     {% for field in fields %}
     {%- set isdate = field.type == "datetime.datetime" or field.type == "typing.Optional[datetime.datetime]" %}
-    {{ field.name }}: {{ field.type }}=dataclasses.field(kw_only=True{% if dataclasses_json_annotation %}, metadata=dataclasses_json.config(field_name="{{ field.original_name }}"{%- if isdate -%}, encoder=lambda d: datetime.datetime.isoformat(d) if d else None, decoder=lambda d:datetime.datetime.fromisoformat(d) if d else None, mm_field=fields.DateTime(format='iso'){%- endif -%}){%- endif %})
+    {{ field.name }}: {{ field.type }}=dataclasses.field(kw_only=True{% if dataclasses_json_annotation %}, metadata=dataclasses_json.config(field_name="{{ field.original_name }}"{%- if isdate -%}, encoder=lambda d: d.isoformat() if isinstance(d, datetime.datetime) else d if d else None, decoder=lambda d: datetime.datetime.fromisoformat(d) if isinstance(d, str) else d if d else None, mm_field=fields.DateTime(format='iso'){%- endif -%}){%- endif %})
     {%- endfor %}
 
     @classmethod

{avrotize-2.20.5 → avrotize-2.21.1}/avrotize/structuretopython/test_class.jinja

@@ -11,12 +11,9 @@ sys.path.append(os.path.realpath(os.path.join(os.path.dirname(__file__), '../src
 from {{ package_name | lower }} import {{ class_name }}
 
 {%- for import_type in import_types if import_type not in ['decimal.Decimal', 'datetime.datetime', 'datetime.date', 'datetime.time', 'datetime.timedelta', 'uuid.UUID'] %}
-{%- set import_type_name = 'Test_'+import_type.split('.')[-1] %}
-{%- set import_package_name = 'test_'+'_'.join(import_type.split('.')[:-1]) | lower %}
-
-{%- if import_type.startswith('.') %}
-from .{{ import_package_name }} import {{ import_type_name }}
-{%- else %}
+{%- set import_type_name = import_type.split('.')[-1] %}
+{%- set import_package_name = '.'.join(import_type.split('.')[:-1]) | lower %}
+{%- if import_package_name %}
 from {{ import_package_name }} import {{ import_type_name }}
 {%- endif -%}
 {%- endfor %}

{avrotize-2.20.5 → avrotize-2.21.1}/avrotize/structuretopython.py

@@ -39,6 +39,7 @@ class StructureToPython:
         self.schema_doc: JsonNode = None
         self.generated_types: Dict[str, str] = {}
         self.generated_structure_types: Dict[str, Dict[str, Union[str, Dict, List]]] = {}
+        self.generated_enum_symbols: Dict[str, List[str]] = {}
         self.type_dict: Dict[str, Dict] = {}
         self.definitions: Dict[str, Any] = {}
         self.schema_registry: Dict[str, Dict] = {}
@@ -285,6 +286,7 @@ class StructureToPython:
         class_name = pascal(explicit_name if explicit_name else structure_schema.get('name', 'UnnamedClass'))
         schema_namespace = structure_schema.get('namespace', parent_namespace)
         namespace = self.concat_namespace(self.base_package, schema_namespace).lower()
+        package_name = self.python_package_from_structure_type(schema_namespace, class_name)
         python_qualified_name = self.python_fully_qualified_name_from_structure_type(schema_namespace, class_name)
         
         if python_qualified_name in self.generated_types:
@@ -357,8 +359,8 @@ class StructureToPython:
         )
 
         if write_file:
-            self.write_to_file(namespace, class_name, class_definition)
-            self.generate_test_class(namespace, class_name, field_docstrings, import_types)
+            self.write_to_file(package_name, class_name, class_definition)
+            self.generate_test_class(package_name, class_name, field_docstrings, import_types)
 
         self.generated_types[python_qualified_name] = 'class'
         self.generated_structure_types[python_qualified_name] = structure_schema
@@ -423,6 +425,7 @@ class StructureToPython:
         class_name = pascal(structure_schema.get('name', field_name + 'Enum'))
         schema_namespace = structure_schema.get('namespace', parent_namespace)
         namespace = self.concat_namespace(self.base_package, schema_namespace).lower()
+        package_name = self.python_package_from_structure_type(schema_namespace, class_name)
         python_qualified_name = self.python_fully_qualified_name_from_structure_type(schema_namespace, class_name)
         
         if python_qualified_name in self.generated_types:
@@ -441,10 +444,11 @@ class StructureToPython:
         )
 
         if write_file:
-            self.write_to_file(namespace, class_name, enum_definition)
-            self.generate_test_enum(namespace, class_name, symbols)
+            self.write_to_file(package_name, class_name, enum_definition)
+            self.generate_test_enum(package_name, class_name, symbols)
 
         self.generated_types[python_qualified_name] = 'enum'
+        self.generated_enum_symbols[python_qualified_name] = symbols
         return python_qualified_name
 
     def generate_choice(self, structure_schema: Dict, parent_namespace: str, 
@@ -511,6 +515,7 @@ class StructureToPython:
         class_name = pascal(structure_schema.get('name', 'UnnamedMap'))
         schema_namespace = structure_schema.get('namespace', parent_namespace)
         namespace = self.concat_namespace(self.base_package, schema_namespace).lower()
+        package_name = self.python_package_from_structure_type(schema_namespace, class_name)
         python_qualified_name = self.python_fully_qualified_name_from_structure_type(schema_namespace, class_name)
         
         if python_qualified_name in self.generated_types:
@@ -535,7 +540,7 @@ class StructureToPython:
         )
         
         if write_file:
-            self.write_to_file(namespace, class_name, map_definition)
+            self.write_to_file(package_name, class_name, map_definition)
         
         self.generated_types[python_qualified_name] = 'map'
         return python_qualified_name
@@ -596,7 +601,24 @@ class StructureToPython:
             elif field_type.startswith('typing.Union['):
                 field_type = resolve(field_type)
                 return generate_value(field_type)
-            return test_values.get(field_type, 'Test_' + field_type + '.create_instance()')
+            if field_type in test_values:
+                return test_values[field_type]
+            # Check if this is an enum type - use first symbol value
+            # Look up by fully qualified name or by short name (class name only)
+            enum_symbols = None
+            if field_type in self.generated_enum_symbols:
+                enum_symbols = self.generated_enum_symbols[field_type]
+            else:
+                # Try to find by short name (the field type might be just the class name)
+                for qualified_name, symbols in self.generated_enum_symbols.items():
+                    if qualified_name.endswith('.' + field_type) or qualified_name == field_type:
+                        enum_symbols = symbols
+                        break
+            if enum_symbols:
+                return f"{field_type.split('.')[-1]}.{enum_symbols[0]}"
+            # For complex types, use None since fields are typically optional
+            # This avoids needing to construct nested objects with required args
+            return 'None'
 
         return generate_value(field_type)
 
@@ -604,7 +626,8 @@ class StructureToPython:
                            import_types: Set[str]) -> None:
         """Generates a unit test class for a Python dataclass"""
         test_class_name = f"Test_{class_name}"
-        tests_package_name = "test_" + package_name.replace('.', '_').lower()
+        # Use a simpler file naming scheme based on class name only
+        test_file_name = f"test_{class_name.lower()}"
         test_class_definition = process_template(
             "structuretopython/test_class.jinja",
             package_name=package_name,
@@ -617,7 +640,7 @@ class StructureToPython:
         )
 
         base_dir = os.path.join(self.output_dir, "tests")
-        test_file_path = os.path.join(base_dir, f"{tests_package_name.replace('.', '_').lower()}.py")
+        test_file_path = os.path.join(base_dir, f"{test_file_name}.py")
         if not os.path.exists(os.path.dirname(test_file_path)):
             os.makedirs(os.path.dirname(test_file_path), exist_ok=True)
         with open(test_file_path, 'w', encoding='utf-8') as file:
@@ -626,7 +649,8 @@ class StructureToPython:
     def generate_test_enum(self, package_name: str, class_name: str, symbols: List[str]) -> None:
         """Generates a unit test class for a Python enum"""
         test_class_name = f"Test_{class_name}"
-        tests_package_name = "test_" + package_name.replace('.', '_').lower()
+        # Use a simpler file naming scheme based on class name only
+        test_file_name = f"test_{class_name.lower()}"
         test_class_definition = process_template(
             "structuretopython/test_enum.jinja",
             package_name=package_name,
@@ -635,7 +659,7 @@ class StructureToPython:
             symbols=symbols
         )
         base_dir = os.path.join(self.output_dir, "tests")
-        test_file_path = os.path.join(base_dir, f"{tests_package_name.replace('.', '_').lower()}.py")
+        test_file_path = os.path.join(base_dir, f"{test_file_name}.py")
         if not os.path.exists(os.path.dirname(test_file_path)):
             os.makedirs(os.path.dirname(test_file_path), exist_ok=True)
         with open(test_file_path, 'w', encoding='utf-8') as file:
@@ -643,9 +667,8 @@ class StructureToPython:
 
     def write_to_file(self, package: str, class_name: str, python_code: str):
         """Writes a Python class to a file"""
-        # Add 'struct' module to the package path
-        full_package = f"{package}.struct"
-        parent_package_name = '.'.join(full_package.split('.')[:-1])
+        # The containing directory is the parent package (matches avrotopython.py)
+        parent_package_name = '.'.join(package.split('.')[:-1])
         parent_package_path = os.sep.join(parent_package_name.split('.')).lower()
         directory_path = os.path.join(self.output_dir, "src", parent_package_path)
         if not os.path.exists(directory_path):
@@ -758,7 +781,11 @@ class StructureToPython:
 def convert_structure_to_python(structure_schema_path, py_file_path, package_name='', dataclasses_json_annotation=False, avro_annotation=False):
     """Converts JSON Structure schema to Python dataclasses"""
     if not package_name:
-        package_name = os.path.splitext(os.path.basename(structure_schema_path))[0].lower().replace('-', '_')
+        # Strip .json extension, then also strip .struct suffix if present (*.struct.json naming convention)
+        base_name = os.path.splitext(os.path.basename(structure_schema_path))[0]
+        if base_name.endswith('.struct'):
+            base_name = base_name[:-7]  # Remove '.struct' suffix
+        package_name = base_name.lower().replace('-', '_')
 
     structure_to_python = StructureToPython(package_name, dataclasses_json_annotation=dataclasses_json_annotation, avro_annotation=avro_annotation)
     structure_to_python.convert(structure_schema_path, py_file_path)

{avrotize-2.20.5 → avrotize-2.21.1}/avrotize/structuretots/class_core.ts.jinja

@@ -19,7 +19,7 @@ export {% if is_abstract %}abstract {% endif %}class {{ class_name }}{% if base_
     /** {{ field.docstring }} */
     {%- if typedjson_annotation %}
     {%- set field_type = field.type_no_null %}
-    @jsonMember({{ field_type if not field.is_primitive else 'String' if field_type == 'Date' else field_type | capitalize }})
+    @jsonMember({{ 'String' if field.is_enum else (field_type if not field.is_primitive else 'String' if field_type == 'Date' else field_type | capitalize) }})
     {%- endif %}
     public {{ field.name }}{% if field.is_optional %}?{% endif %}: {{ field.type_no_null }};
     {%- endfor %}
@@ -63,4 +63,16 @@ export {% if is_abstract %}abstract {% endif %}class {{ class_name }}{% if base_
         return result;
     }
     {%- endif %}
+
+    /**
+     * Creates an instance of {{ class_name }} with sample data for testing.
+     * @returns A new {{ class_name }} instance with sample values.
+     */
+    public static createInstance(): {{ class_name }} {
+        return new {{ class_name }}(
+            {%- for field in required_fields %}
+            {{ field.test_value }}{% if not loop.last %},{% endif %}  // {{ field.name }}
+            {%- endfor %}
+        );
+    }
 }

{avrotize-2.20.5 → avrotize-2.21.1}/avrotize/structuretots/package.json.jinja

@@ -31,6 +31,9 @@
     ],
     "testMatch": [
       "**/*.test.ts"
-    ]
+    ],
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.js$": "$1"
+    }
   }
 }

{avrotize-2.20.5 → avrotize-2.21.1}/avrotize/structuretots/test_class.ts.jinja

@@ -3,6 +3,9 @@
  */
 
 import { {{ class_name }} } from '../src/{{ relative_path }}';
+{%- for enum_type, enum_path in enum_imports.items() %}
+import { {{ enum_type }} } from '{{ enum_path }}';
+{%- endfor %}
 
 describe('{{ class_name }}', () => {
     it('should create an instance with required fields', () => {