structurize 2.18.1__tar.gz → 2.19.0__tar.gz

{structurize-2.18.1/structurize.egg-info → structurize-2.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structurize
-Version: 2.18.1
+Version: 2.19.0
 Summary: Tools to convert from and to JSON Structure from various other schema languages.
 Author-email: Clemens Vasters <clemensv@microsoft.com>
 Classifier: Programming Language :: Python :: 3

{structurize-2.18.1 → structurize-2.19.0}/avrotize/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.18.1'
-__version_tuple__ = version_tuple = (2, 18, 1)
+__version__ = version = '2.19.0'
+__version_tuple__ = version_tuple = (2, 19, 0)
 
-__commit_id__ = commit_id = 'gdae473138'
+__commit_id__ = commit_id = 'geec8f9840'

{structurize-2.18.1 → structurize-2.19.0}/avrotize/avrotocsharp.py

@@ -9,6 +9,15 @@ from typing import Any, Dict, List, Tuple, Union, cast
 import uuid
 
 from avrotize.common import build_flat_type_dict, inline_avro_references, is_generic_avro_type, pascal, process_template
+from avrotize.constants import (
+    CSHARP_AVRO_VERSION,
+    NEWTONSOFT_JSON_VERSION,
+    SYSTEM_TEXT_JSON_VERSION,
+    SYSTEM_MEMORY_DATA_VERSION,
+    NUNIT_VERSION,
+    NUNIT_ADAPTER_VERSION,
+    MSTEST_SDK_VERSION,
+)
 import glob
 
 JsonNode = Dict[str, 'JsonNode'] | List['JsonNode'] | str | None
@@ -957,7 +966,14 @@ class AvroToCSharp:
                         avro_annotation=self.avro_annotation,
                         system_xml_annotation=self.system_xml_annotation,
                         system_text_json_annotation=self.system_text_json_annotation,
-                        newtonsoft_json_annotation=self.newtonsoft_json_annotation))
+                        newtonsoft_json_annotation=self.newtonsoft_json_annotation,
+                        CSHARP_AVRO_VERSION=CSHARP_AVRO_VERSION,
+                        NEWTONSOFT_JSON_VERSION=NEWTONSOFT_JSON_VERSION,
+                        SYSTEM_TEXT_JSON_VERSION=SYSTEM_TEXT_JSON_VERSION,
+                        SYSTEM_MEMORY_DATA_VERSION=SYSTEM_MEMORY_DATA_VERSION,
+                        NUNIT_VERSION=NUNIT_VERSION,
+                        NUNIT_ADAPTER_VERSION=NUNIT_ADAPTER_VERSION,
+                        MSTEST_SDK_VERSION=MSTEST_SDK_VERSION))
         if not glob.glob(os.path.join(output_dir, "test", "*.csproj")):
             csproj_test_file = os.path.join(
                 output_dir, "test", f"{pascal(project_name)}.Test.csproj")
@@ -971,7 +987,10 @@ class AvroToCSharp:
                         avro_annotation=self.avro_annotation,
                         system_xml_annotation=self.system_xml_annotation,
                         system_text_json_annotation=self.system_text_json_annotation,
-                        newtonsoft_json_annotation=self.newtonsoft_json_annotation))
+                        newtonsoft_json_annotation=self.newtonsoft_json_annotation,
+                        NUNIT_VERSION=NUNIT_VERSION,
+                        NUNIT_ADAPTER_VERSION=NUNIT_ADAPTER_VERSION,
+                        MSTEST_SDK_VERSION=MSTEST_SDK_VERSION))
 
         self.output_dir = output_dir
         for avro_schema in (avs for avs in schema if isinstance(avs, dict)):

{structurize-2.18.1 → structurize-2.19.0}/avrotize/avrotojava.py

@@ -4,7 +4,8 @@
 import json
 import os
 from typing import Dict, List, Tuple, Union
-from avrotize.constants import AVRO_VERSION, JACKSON_VERSION, JDK_VERSION
+from avrotize.constants import (AVRO_VERSION, JACKSON_VERSION, JDK_VERSION, 
+                                  JUNIT_VERSION, MAVEN_COMPILER_VERSION, MAVEN_SUREFIRE_VERSION)
 
 from avrotize.common import pascal, camel, is_generic_avro_type, inline_avro_references, build_flat_type_dict
 
@@ -46,13 +47,13 @@ POM_CONTENT = """<?xml version="1.0" encoding="UTF-8"?>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-api</artifactId>
-            <version>5.10.0</version>
+            <version>{JUNIT_VERSION}</version>
             <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-engine</artifactId>
-            <version>5.10.0</version>
+            <version>{JUNIT_VERSION}</version>
             <scope>test</scope>
         </dependency>
     </dependencies>
@@ -61,7 +62,7 @@ POM_CONTENT = """<?xml version="1.0" encoding="UTF-8"?>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.11.0</version>
+                <version>{MAVEN_COMPILER_VERSION}</version>
                 <configuration>
                     <compilerArgs>
                         <arg>-Xmaxerrs</arg>
@@ -72,7 +73,7 @@ POM_CONTENT = """<?xml version="1.0" encoding="UTF-8"?>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-surefire-plugin</artifactId>
-                <version>3.0.0-M9</version>
+                <version>{MAVEN_SUREFIRE_VERSION}</version>
                 <configuration>
                     <useSystemClassLoader>false</useSystemClassLoader>
                 </configuration>
@@ -693,7 +694,8 @@ class AvroToJava:
             elif items_type in self.generated_types_java_package:
                 kind = self.generated_types_java_package[items_type]
                 if kind == "enum":
-                    pred += f"n.elements().next().isTextual() && Enum.valueOf({items_type}.class, n.elements().next().asText()) != null"
+                    # Try to match the incoming text against Avro symbols
+                    pred += f"n.elements().next().isTextual() && java.util.Arrays.stream({items_type}.values()).anyMatch(e -> e.avroSymbol().equals(n.elements().next().asText()))"
                 else:
                     pred += f"{items_type}.isJsonMatch(n.elements().next())"
             else:
@@ -710,7 +712,8 @@ class AvroToJava:
             elif values_type in self.generated_types_java_package:
                 kind = self.generated_types_java_package[values_type]
                 if kind == "enum":
-                    pred += f"n.elements().next().isTextual() && Enum.valueOf({values_type}.class, n.elements().next().asText()) != null"
+                    # Try to match the incoming text against Avro symbols
+                    pred += f"n.elements().next().isTextual() && java.util.Arrays.stream({values_type}.values()).anyMatch(e -> e.avroSymbol().equals(n.elements().next().asText()))"
                 else:
                     pred += f"{values_type}.isJsonMatch(n.elements().next())"
             else:
@@ -730,7 +733,8 @@ class AvroToJava:
                 raw_const = const_value if isinstance(const_value, str) else str(const_value)
                 class_definition += f"(node.has(\"{field_name_js}\") && node.get(\"{field_name_js}\").isTextual() && node.get(\"{field_name_js}\").asText().equals(\"{raw_const}\"))"
             else:
-                class_definition += f"(node.get(\"{field_name_js}\").isTextual() && Enum.valueOf({field_type.type_name}.class, node.get(\"{field_name_js}\").asText()) != null)"
+                # Try to match the incoming text against Avro symbols
+                class_definition += f"(node.get(\"{field_name_js}\").isTextual() && java.util.Arrays.stream({field_type.type_name}.values()).anyMatch(e -> e.avroSymbol().equals(node.get(\"{field_name_js}\").asText())))"
         else:
             is_union = False
             field_union = pascal(field_name) + 'Union'
@@ -802,7 +806,8 @@ class AvroToJava:
         elif field_type.is_class:
             class_definition += f"({null_check} || {field_type.type_name}.isJsonMatch({element_name}))"
         elif field_type.is_enum:
-            class_definition += f"({null_check} || ({node_check}.isTextual() && Enum.valueOf({field_type.type_name}.class, {element_name}.asText()) != null))"
+            # Try to match the incoming text against Avro symbols
+            class_definition += f"({null_check} || ({node_check}.isTextual() && java.util.Arrays.stream({field_type.type_name}.values()).anyMatch(e -> e.avroSymbol().equals({element_name}.asText()))))"
         else:
             is_union = False
             field_union = pascal(element_name) + 'Union'
@@ -1022,8 +1027,8 @@ class AvroToJava:
                 get_method += f"{INDENT * 3}case {index}: return this.{field_name} != null ? this.{field_name}.entrySet().stream().collect(java.util.stream.Collectors.toMap(java.util.Map.Entry::getKey, e -> e.getValue() != null ? e.getValue().toObject() : null)) : null;\n"
             elif field_type.is_enum:
                 # For enum fields, convert to GenericEnumSymbol for Avro serialization
-                # This allows SpecificDatumWriter to serialize enums inside unions correctly
-                get_method += f"{INDENT * 3}case {index}: return this.{field_name} != null ? new GenericData.EnumSymbol({field_type.type_name}.SCHEMA, this.{field_name}.name()) : null;\n"
+                # Use avroSymbol() to get the original Avro symbol name for serialization
+                get_method += f"{INDENT * 3}case {index}: return this.{field_name} != null ? new GenericData.EnumSymbol({field_type.type_name}.SCHEMA, this.{field_name}.avroSymbol()) : null;\n"
             else:
                 # For all other field types, return the field as-is
                 # Avro's SpecificDatumWriter will handle serialization internally
@@ -1104,7 +1109,8 @@ class AvroToJava:
                 put_method += f"{INDENT * 3}case {index}: this.{field_name} = value$ instanceof GenericData.Record ? new {field_type.type_name}((GenericData.Record)value$) : ({field_type.type_name})value$; break;\n"
             elif type_kind == "enum":
                 # Enums need to be converted from GenericData.EnumSymbol
-                put_method += f"{INDENT * 3}case {index}: this.{field_name} = value$ instanceof GenericData.EnumSymbol ? {field_type.type_name}.valueOf(value$.toString()) : ({field_type.type_name})value$; break;\n"
+                # Use fromAvroSymbol to match original Avro symbol names
+                put_method += f"{INDENT * 3}case {index}: this.{field_name} = value$ instanceof GenericData.EnumSymbol ? {field_type.type_name}.fromAvroSymbol(value$.toString()) : ({field_type.type_name})value$; break;\n"
             else:
                 # Check if this is a List<RecordType> or Map<String,RecordType>
                 is_list_of_records = False
@@ -1164,10 +1170,11 @@ class AvroToJava:
                     # Check if it's a List of enums
                     if element_type in self.generated_types_java_package and self.generated_types_java_package[element_type] == "enum":
                         # For List<Enum>, convert GenericEnumSymbol to actual enum values
+                        # Use fromAvroSymbol to match original Avro symbol names
                         put_method += f"{INDENT * 3}case {index}: {{\n"
                         put_method += f"{INDENT * 4}if (value$ instanceof List<?>) {{\n"
                         put_method += f"{INDENT * 5}List<?> list = (List<?>)value$;\n"
-                        put_method += f"{INDENT * 5}this.{field_name} = list.stream().map(item -> item instanceof GenericData.EnumSymbol ? {element_type}.valueOf(item.toString()) : ({element_type})item).collect(java.util.stream.Collectors.toList());\n"
+                        put_method += f"{INDENT * 5}this.{field_name} = list.stream().map(item -> item instanceof GenericData.EnumSymbol ? {element_type}.fromAvroSymbol(item.toString()) : ({element_type})item).collect(java.util.stream.Collectors.toList());\n"
                         put_method += f"{INDENT * 4}}} else {{\n"
                         put_method += f"{INDENT * 5}this.{field_name} = null;\n"
                         put_method += f"{INDENT * 4}}}\n"
@@ -1211,20 +1218,44 @@ class AvroToJava:
         self.generated_types_java_package[type_name] = "enum"
         self.generated_avro_schemas[type_name] = avro_schema
         symbols = avro_schema.get('symbols', [])
-        # Convert symbols to valid Java identifiers, preserving case
+        # Convert symbols to valid Java identifiers in SCREAMING_CASE (uppercase)
         # Replace invalid chars, prepend _ if starts with digit or is a reserved word
+        # Keep track of mapping from Java symbol to original Avro symbol for serialization
         java_symbols = []
+        symbol_pairs = []  # (java_symbol, avro_symbol) pairs
         for symbol in symbols:
-            java_symbol = symbol.replace('-', '_').replace('.', '_')
+            java_symbol = symbol.replace('-', '_').replace('.', '_').upper()
             if java_symbol and java_symbol[0].isdigit():
                 java_symbol = '_' + java_symbol
             # Check if the symbol is a Java reserved word and prefix with underscore
-            if is_java_reserved_word(java_symbol):
+            if is_java_reserved_word(java_symbol.lower()):
                 java_symbol = '_' + java_symbol
             java_symbols.append(java_symbol)
-        symbols_str = ', '.join(java_symbols)
+            symbol_pairs.append((java_symbol, symbol))
+        
+        # Build enum with avroSymbol field for proper Avro serialization
         enum_definition += f"public enum {enum_name} {{\n"
-        enum_definition += f"{INDENT}{symbols_str}"
+        # Each enum constant has its original Avro symbol stored
+        enum_constants = []
+        for java_symbol, avro_symbol in symbol_pairs:
+            enum_constants.append(f'{java_symbol}("{avro_symbol}")')
+        enum_definition += f"{INDENT}" + ", ".join(enum_constants)
+        
+        # Add avroSymbol field and method with Jackson annotations for proper JSON serialization
+        enum_definition += f";\n\n{INDENT}private final String avroSymbol;\n\n"
+        enum_definition += f"{INDENT}{enum_name}(String avroSymbol) {{\n{INDENT*2}this.avroSymbol = avroSymbol;\n{INDENT}}}\n\n"
+        # @JsonValue tells Jackson to serialize the enum using avroSymbol() value
+        enum_definition += f"{INDENT}@com.fasterxml.jackson.annotation.JsonValue\n"
+        enum_definition += f"{INDENT}public String avroSymbol() {{\n{INDENT*2}return avroSymbol;\n{INDENT}}}\n\n"
+        
+        # Add static lookup method to find enum by Avro symbol with @JsonCreator for deserialization
+        enum_definition += f"{INDENT}@com.fasterxml.jackson.annotation.JsonCreator\n"
+        enum_definition += f"{INDENT}public static {enum_name} fromAvroSymbol(String symbol) {{\n"
+        enum_definition += f"{INDENT*2}for ({enum_name} e : values()) {{\n"
+        enum_definition += f"{INDENT*3}if (e.avroSymbol.equals(symbol)) return e;\n"
+        enum_definition += f"{INDENT*2}}}\n"
+        enum_definition += f"{INDENT*2}throw new IllegalArgumentException(\"Unknown symbol: \" + symbol);\n"
+        enum_definition += f"{INDENT}}}\n"
         
         # Add Avro schema if annotations are enabled
         if self.avro_annotation:
@@ -1245,9 +1276,7 @@ class AvroToJava:
                 [enum_schema_json[i:i+80] for i in range(0, len(enum_schema_json), 80)])
             enum_schema_json = enum_schema_json.replace('§', '\\"')
             
-            enum_definition += f";\n\n{INDENT}public static final Schema SCHEMA = new Schema.Parser().parse(\n{INDENT}\"{enum_schema_json}\");\n"
-        else:
-            enum_definition += f";\n"
+            enum_definition += f"\n{INDENT}public static final Schema SCHEMA = new Schema.Parser().parse(\n{INDENT}\"{enum_schema_json}\");\n"
         
         enum_definition += "}\n"
         if write_file:
@@ -1295,8 +1324,9 @@ class AvroToJava:
                 f"{INDENT*1}public {union_type.type_name} get{union_variable_name}() {{ return _{camel(union_variable_name)}; }}\n";
                 
             # For toObject(), wrap enums in GenericData.EnumSymbol so Avro can serialize them
+            # Use avroSymbol() to get the original Avro symbol name for serialization
             if union_type.is_enum:
-                class_definition_toobject += f"{INDENT*2}if (_{camel(union_variable_name)} != null) {{\n{INDENT*3}return new GenericData.EnumSymbol({union_type.type_name}.SCHEMA, _{camel(union_variable_name)}.name());\n{INDENT*2}}}\n"
+                class_definition_toobject += f"{INDENT*2}if (_{camel(union_variable_name)} != null) {{\n{INDENT*3}return new GenericData.EnumSymbol({union_type.type_name}.SCHEMA, _{camel(union_variable_name)}.avroSymbol());\n{INDENT*2}}}\n"
             else:
                 class_definition_toobject += f"{INDENT*2}if (_{camel(union_variable_name)} != null) {{\n{INDENT*3}return _{camel(union_variable_name)};\n{INDENT*2}}}\n"
             
@@ -1326,8 +1356,9 @@ class AvroToJava:
                     class_definition_fromobjectctor += f"{INDENT*2}if (obj instanceof org.apache.avro.util.Utf8) {{\n{INDENT*3}this._{camel(union_variable_name)} = obj.toString();\n{INDENT*3}return;\n{INDENT*2}}}\n"
                 
                 # Handle Avro's GenericEnumSymbol for enum types
+                # Use fromAvroSymbol to match original Avro symbol names
                 if self.avro_annotation and union_type.is_enum:
-                    class_definition_fromobjectctor += f"{INDENT*2}if (obj instanceof GenericData.EnumSymbol) {{\n{INDENT*3}this._{camel(union_variable_name)} = {union_type.type_name}.valueOf(obj.toString());\n{INDENT*3}return;\n{INDENT*2}}}\n"
+                    class_definition_fromobjectctor += f"{INDENT*2}if (obj instanceof GenericData.EnumSymbol) {{\n{INDENT*3}this._{camel(union_variable_name)} = {union_type.type_name}.fromAvroSymbol(obj.toString());\n{INDENT*3}return;\n{INDENT*2}}}\n"
                 
                 class_definition_fromobjectctor += f"{INDENT*2}if (obj instanceof {union_type.type_name}) {{\n{INDENT*3}this._{camel(union_variable_name)} = ({union_type.type_name})obj;\n{INDENT*3}return;\n{INDENT*2}}}\n"
 
@@ -1356,7 +1387,8 @@ class AvroToJava:
             else:
                 # For classes and enums, use duck typing with isJsonMatch() (C# pattern)
                 if union_type.is_enum:
-                    class_definition_read += f"{INDENT*3}if (node.isTextual()) {{\n{INDENT*4}return new {union_class_name}(Enum.valueOf({union_type.type_name}.class, node.asText()));\n{INDENT*3}}}\n"
+                    # Use fromAvroSymbol to match original Avro symbol names
+                    class_definition_read += f"{INDENT*3}if (node.isTextual()) {{\n{INDENT*4}return new {union_class_name}({union_type.type_name}.fromAvroSymbol(node.asText()));\n{INDENT*3}}}\n"
                 elif union_type.is_class:
                     # Use isJsonMatch() to test if this type matches, then use fromData() to deserialize
                     class_definition_read += f"{INDENT*3}if ({union_type.type_name}.isJsonMatch(node)) {{\n{INDENT*4}return new {union_class_name}({union_type.type_name}.fromData(node, \"application/json\"));\n{INDENT*3}}}\n"
@@ -1449,9 +1481,15 @@ class AvroToJava:
             const_value = field['const']
             is_discriminator = field.get('discriminator', False)
             
-            # For enum types, qualify with the enum type name
+            # For enum types, qualify with the enum type name and convert to SCREAMING_CASE
             if field_type.type_name not in ('String', 'int', 'Integer', 'long', 'Long', 'double', 'Double', 'boolean', 'Boolean'):
-                const_value = f'{field_type.type_name}.{const_value}'
+                # Convert enum const value to uppercase to match Java enum constant naming convention
+                const_value_upper = str(const_value).replace('-', '_').replace('.', '_').upper()
+                if const_value_upper and const_value_upper[0].isdigit():
+                    const_value_upper = '_' + const_value_upper
+                if is_java_reserved_word(const_value_upper.lower()):
+                    const_value_upper = '_' + const_value_upper
+                const_value = f'{field_type.type_name}.{const_value_upper}'
             elif field_type.type_name == 'String':
                 const_value = f'"{const_value}"'
             
@@ -1464,11 +1502,12 @@ class AvroToJava:
                     property_def += f"{INDENT}@JsonIgnore\n"
                 property_def += f"{INDENT}public {field_type.type_name} get{pascal(field_name)}Value() {{ return {safe_field_name}; }}\n"
                 # Generate the getter that returns String (Jackson will use this for serialization)
+                # Use avroSymbol() to get the original Avro symbol name for serialization
                 # Use READ_ONLY since this is a const field that doesn't need deserialization
                 # Note: Not using @Override because not all discriminated union variants extend a base class
                 if self.jackson_annotations:
                     property_def += f"{INDENT}@JsonProperty(value=\"{field['name']}\", access=JsonProperty.Access.READ_ONLY)\n"
-                property_def += f"{INDENT}public String get{pascal(field_name)}() {{ return {safe_field_name}.name(); }}\n"
+                property_def += f"{INDENT}public String get{pascal(field_name)}() {{ return {safe_field_name}.avroSymbol(); }}\n"
             else:
                 property_def += f"{INDENT}public {field_type.type_name} get{pascal(field_name)}() {{ return {safe_field_name}; }}\n"
         else:
@@ -1651,14 +1690,14 @@ class AvroToJava:
                 jackson_annotation=self.jackson_annotations
             )
         elif type_kind == "enum":
-            # Convert symbols to Java-safe identifiers (same logic as generate_enum)
+            # Convert symbols to Java-safe identifiers in SCREAMING_CASE (same logic as generate_enum)
             raw_symbols = avro_schema.get('symbols', [])
             java_safe_symbols = []
             for symbol in raw_symbols:
-                java_symbol = symbol.replace('-', '_').replace('.', '_')
+                java_symbol = symbol.replace('-', '_').replace('.', '_').upper()
                 if java_symbol and java_symbol[0].isdigit():
                     java_symbol = '_' + java_symbol
-                if is_java_reserved_word(java_symbol):
+                if is_java_reserved_word(java_symbol.lower()):
                     java_symbol = '_' + java_symbol
                 java_safe_symbols.append(java_symbol)
             
@@ -1808,9 +1847,15 @@ class AvroToJava:
                 # Generate test value for the field
                 if "const" in field and field["const"] is not None:
                     const_value = field["const"]
-                    # For enum types, qualify with the enum type name
+                    # For enum types, qualify with the enum type name and convert to SCREAMING_CASE
                     if is_enum or (field_type.type_name not in ('String', 'int', 'Integer', 'long', 'Long', 'double', 'Double', 'boolean', 'Boolean')):
-                        test_value = f'{field_type.type_name}.{const_value}'
+                        # Convert enum const value to uppercase to match Java enum constant naming convention
+                        const_value_upper = str(const_value).replace('-', '_').replace('.', '_').upper()
+                        if const_value_upper and const_value_upper[0].isdigit():
+                            const_value_upper = '_' + const_value_upper
+                        if is_java_reserved_word(const_value_upper.lower()):
+                            const_value_upper = '_' + const_value_upper
+                        test_value = f'{field_type.type_name}.{const_value_upper}'
                     else:
                         test_value = f'"{const_value}"'
                 else:
@@ -1896,12 +1941,12 @@ class AvroToJava:
                 avro_schema = self.generated_avro_schemas.get(java_type, {})
                 symbols = avro_schema.get('symbols', [])
                 if symbols:
-                    # Convert symbol to valid Java identifier (same logic as in generate_enum)
-                    first_symbol = symbols[0].replace('-', '_').replace('.', '_')
+                    # Convert symbol to valid Java identifier in SCREAMING_CASE (same logic as in generate_enum)
+                    first_symbol = symbols[0].replace('-', '_').replace('.', '_').upper()
                     if first_symbol and first_symbol[0].isdigit():
                         first_symbol = '_' + first_symbol
                     # Check if the symbol is a Java reserved word and prefix with underscore
-                    if is_java_reserved_word(first_symbol):
+                    if is_java_reserved_word(first_symbol.lower()):
                         first_symbol = '_' + first_symbol
                     # Use fully qualified name to avoid conflicts with field names
                     return f'{java_type}.{first_symbol}'
@@ -2048,7 +2093,16 @@ class AvroToJava:
             groupid = '.'.join(package_elements[:-1]) if len(package_elements) > 1 else package_elements[0]
             artifactid = package_elements[-1]
             with open(pom_path, 'w', encoding='utf-8') as file:
-                file.write(POM_CONTENT.format(groupid=groupid, artifactid=artifactid, AVRO_VERSION=AVRO_VERSION, JACKSON_VERSION=JACKSON_VERSION, JDK_VERSION=JDK_VERSION, PACKAGE=self.base_package))
+                file.write(POM_CONTENT.format(
+                    groupid=groupid, 
+                    artifactid=artifactid, 
+                    AVRO_VERSION=AVRO_VERSION, 
+                    JACKSON_VERSION=JACKSON_VERSION, 
+                    JDK_VERSION=JDK_VERSION, 
+                    JUNIT_VERSION=JUNIT_VERSION,
+                    MAVEN_COMPILER_VERSION=MAVEN_COMPILER_VERSION,
+                    MAVEN_SUREFIRE_VERSION=MAVEN_SUREFIRE_VERSION,
+                    PACKAGE=self.base_package))
         output_dir = os.path.join(
             output_dir, "src/main/java".replace('/', os.sep))
         if not os.path.exists(output_dir):