avrotize 2.21.1__tar.gz → 2.22.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: avrotize
-Version: 2.21.1
+Version: 2.22.0
 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.21.1 → avrotize-2.22.0}/avrotize/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.21.1'
-__version_tuple__ = version_tuple = (2, 21, 1)
+__version__ = version = '2.22.0'
+__version_tuple__ = version_tuple = (2, 22, 0)
 
-__commit_id__ = commit_id = 'g9b9841dd3'
+__commit_id__ = commit_id = 'g5d3e04df0'

{avrotize-2.21.1 → avrotize-2.22.0}/avrotize/avrotogo.py

@@ -10,8 +10,15 @@ JsonNode = Dict[str, 'JsonNode'] | List['JsonNode'] | str | None
 class AvroToGo:
     """Converts Avro schema to Go structs, including JSON and Avro marshalling methods"""
 
+    # Go reserved keywords that cannot be used as package names
+    GO_RESERVED_WORDS = [
+        'break', 'default', 'func', 'interface', 'select', 'case', 'defer', 'go', 'map', 'struct', 'chan',
+        'else', 'goto', 'package', 'switch', 'const', 'fallthrough', 'if', 'range', 'type', 'continue', 'for',
+        'import', 'return', 'var',
+    ]
+
     def __init__(self, base_package: str = '') -> None:
-        self.base_package = base_package
+        self.base_package = self._safe_package_name(base_package) if base_package else base_package
         self.output_dir = os.getcwd()
         self.generated_types_avro_namespace: Dict[str, str] = {}
         self.generated_types_go_package: Dict[str, str] = {}
@@ -25,14 +32,15 @@ class AvroToGo:
         self.structs = []
         self.enums = []
 
+    def _safe_package_name(self, name: str) -> str:
+        """Converts a name to a safe Go package name"""
+        if name in self.GO_RESERVED_WORDS:
+            return f"{name}_"
+        return name
+
     def safe_identifier(self, name: str) -> str:
         """Converts a name to a safe Go identifier"""
-        reserved_words = [
-            'break', 'default', 'func', 'interface', 'select', 'case', 'defer', 'go', 'map', 'struct', 'chan',
-            'else', 'goto', 'package', 'switch', 'const', 'fallthrough', 'if', 'range', 'type', 'continue', 'for',
-            'import', 'return', 'var',
-        ]
-        if name in reserved_words:
+        if name in self.GO_RESERVED_WORDS:
             return f"{name}_"
         return name
 
@@ -157,6 +165,10 @@ class AvroToGo:
             'original_name': field['name']
         } for field in avro_schema.get('fields', [])]
 
+        # Collect imports from field types
+        go_types = [f['type'] for f in fields]
+        imports = self.get_imports_for_definition(go_types)
+
         context = {
             'doc': avro_schema.get('doc', ''),
             'struct_name': go_struct_name,
@@ -166,6 +178,7 @@ class AvroToGo:
             'avro_annotation': self.avro_annotation,
             'json_match_predicates': [self.get_is_json_match_clause(f['name'], f['type']) for f in fields],
             'base_package': self.base_package,
+            'imports': imports,
         }
 
         pkg_dir = os.path.join(self.output_dir, 'pkg', self.base_package)
@@ -430,7 +443,7 @@ class AvroToGo:
     def convert(self, avro_schema_path: str, output_dir: str):
         """Converts Avro schema to Go"""
         if not self.base_package:
-            self.base_package = os.path.splitext(os.path.basename(avro_schema_path))[0]
+            self.base_package = self._safe_package_name(os.path.splitext(os.path.basename(avro_schema_path))[0])
 
         with open(avro_schema_path, 'r', encoding='utf-8') as file:
             schema = json.load(file)

{avrotize-2.21.1 → avrotize-2.22.0}/avrotize/avrotojava/class_test.java.jinja

@@ -113,8 +113,7 @@ public class {{ test_class_name }} {
             "Instances with different {{ field.field_name }} should not be equal");
         {%- elif field.is_enum %}
         // Enum - try to get a different enum value if more than one value exists
-        {%- set simple_type = base_type.split('.')[-1] if '.' in base_type else base_type %}
-        {{ simple_type }}[] enumValues = {{ simple_type }}.values();
+        {{ base_type }}[] enumValues = {{ base_type }}.values();
         if (enumValues.length > 1) {
             instance2.set{{ field.field_name | pascal }}(enumValues[(instance2.get{{ field.field_name | pascal }}().ordinal() + 1) % enumValues.length]);
             assertNotEquals(instance1, instance2, 
@@ -150,8 +149,7 @@ public class {{ test_class_name }} {
         {%- if '<' in field.field_type %}
         {{ field.field_type }} testValue = {{ field.test_value }};
         {%- else %}
-        {%- set simple_field_type = field.field_type.split('.')[-1] if '.' in field.field_type else field.field_type %}
-        {{ simple_field_type }} testValue = {{ field.test_value }};
+        {{ field.field_type }} testValue = {{ field.test_value }};
         {%- endif %}
         {%- if not field.is_const %}
         instance.set{{ field.field_name | pascal }}(testValue);

{avrotize-2.21.1 → avrotize-2.22.0}/avrotize/avrotojava.py

@@ -1721,6 +1721,51 @@ class AvroToJava:
     def get_test_imports(self, fields: List) -> List[str]:
         """ Gets the necessary imports for the test class """
         imports = []
+        
+        # Track simple names to detect conflicts
+        # Map: simple_name -> list of FQNs that have that simple name
+        simple_name_to_fqns: Dict[str, List[str]] = {}
+        
+        # First pass: collect all custom type FQNs and their simple names
+        for field in fields:
+            inner_types = []
+            if field.field_type.startswith("List<"):
+                inner_type = field.field_type[5:-1]
+                if inner_type.startswith("Map<"):
+                    start = inner_type.index('<') + 1
+                    end = inner_type.rindex('>')
+                    map_types = inner_type[start:end].split(',')
+                    if len(map_types) > 1:
+                        inner_types.append(map_types[1].strip())
+                else:
+                    inner_types.append(inner_type)
+            elif field.field_type.startswith("Map<"):
+                start = field.field_type.index('<') + 1
+                end = field.field_type.rindex('>')
+                map_types = field.field_type[start:end].split(',')
+                if len(map_types) > 1:
+                    inner_types.append(map_types[1].strip())
+            if not field.field_type.startswith(("List<", "Map<")):
+                inner_types.append(field.field_type)
+            if hasattr(field, 'java_type_obj') and field.java_type_obj and field.java_type_obj.union_types:
+                for union_member_type in field.java_type_obj.union_types:
+                    inner_types.append(union_member_type.type_name)
+            
+            for type_to_check in inner_types:
+                if type_to_check in self.generated_types_java_package and '.' in type_to_check:
+                    simple_name = type_to_check.split('.')[-1]
+                    if simple_name not in simple_name_to_fqns:
+                        simple_name_to_fqns[simple_name] = []
+                    if type_to_check not in simple_name_to_fqns[simple_name]:
+                        simple_name_to_fqns[simple_name].append(type_to_check)
+        
+        # Find conflicting simple names (same simple name, different FQNs)
+        conflicting_fqns: set = set()
+        for simple_name, fqns in simple_name_to_fqns.items():
+            if len(fqns) > 1:
+                # This simple name has conflicts - mark all FQNs as conflicting
+                conflicting_fqns.update(fqns)
+        
         for field in fields:
             # Extract inner types from generic collections
             inner_types = []
@@ -1772,7 +1817,8 @@ class AvroToJava:
                 if type_to_check in self.generated_types_java_package:
                     type_kind = self.generated_types_java_package[type_to_check]
                     # Only import if it's a fully qualified name with a package
-                    if '.' in type_to_check:
+                    # Skip imports for types with conflicting simple names - they'll use FQN
+                    if '.' in type_to_check and type_to_check not in conflicting_fqns:
                         import_stmt = f"import {type_to_check};"
                         if import_stmt not in imports:
                             imports.append(import_stmt)
@@ -1809,10 +1855,11 @@ class AvroToJava:
                                     if java_qualified_name:
                                         if java_qualified_name in self.generated_types_java_package or java_qualified_name.split('.')[-1] in self.generated_types_java_package:
                                             member_type_kind = self.generated_types_java_package.get(java_qualified_name, self.generated_types_java_package.get(java_qualified_name.split('.')[-1], None))
-                                            # Import the class/enum
-                                            class_import = f"import {java_qualified_name};"
-                                            if class_import not in imports:
-                                                imports.append(class_import)
+                                            # Import the class/enum only if not conflicting
+                                            if java_qualified_name not in conflicting_fqns:
+                                                class_import = f"import {java_qualified_name};"
+                                                if class_import not in imports:
+                                                    imports.append(class_import)
                                             # No longer import test classes - we instantiate classes directly
         return imports
 
@@ -1920,6 +1967,21 @@ class AvroToJava:
             'Double': 'Double.valueOf(3.14)',
             'byte[]': 'new byte[] { 0x01, 0x02, 0x03 }',
             'Object': 'null',  # Use null for Object types (Avro unions) to avoid reference equality issues
+            # Java time types - use factory methods, not constructors
+            'Instant': 'java.time.Instant.now()',
+            'java.time.Instant': 'java.time.Instant.now()',
+            'LocalDate': 'java.time.LocalDate.now()',
+            'java.time.LocalDate': 'java.time.LocalDate.now()',
+            'LocalTime': 'java.time.LocalTime.now()',
+            'java.time.LocalTime': 'java.time.LocalTime.now()',
+            'LocalDateTime': 'java.time.LocalDateTime.now()',
+            'java.time.LocalDateTime': 'java.time.LocalDateTime.now()',
+            'Duration': 'java.time.Duration.ofSeconds(42)',
+            'java.time.Duration': 'java.time.Duration.ofSeconds(42)',
+            'UUID': 'java.util.UUID.randomUUID()',
+            'java.util.UUID': 'java.util.UUID.randomUUID()',
+            'BigDecimal': 'new java.math.BigDecimal("42.00")',
+            'java.math.BigDecimal': 'new java.math.BigDecimal("42.00")',
         }
         
         # Handle generic types

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

@@ -25,7 +25,7 @@ import avro.schema
 import avro.name
 import avro.io
 {%- endif %}
-{%- for import_type in import_types if import_type not in ['datetime.datetime', 'datetime.date', 'datetime.time', 'datetime.timedelta', 'decimal.Decimal'] %}
+{%- for import_type in import_types if import_type not in ['datetime.datetime', 'datetime.date', 'datetime.time', 'datetime.timedelta', 'decimal.Decimal', 'uuid.UUID'] %}
 from {{ '.'.join(import_type.split('.')[:-1]) | lower }} import {{ import_type.split('.')[-1] }}
 {%- endfor %}
 {%- for import_type in import_types if import_type in ['datetime.datetime', 'datetime.date', 'datetime.time', 'datetime.timedelta'] %}
@@ -33,6 +33,16 @@ from {{ '.'.join(import_type.split('.')[:-1]) | lower }} import {{ import_type.s
 import datetime
 {%- endif %}
 {%- endfor %}
+{%- for import_type in import_types if import_type == 'decimal.Decimal' %}
+{%- if loop.first %}
+import decimal
+{%- endif %}
+{%- endfor %}
+{%- for import_type in import_types if import_type == 'uuid.UUID' %}
+{%- if loop.first %}
+import uuid
+{%- endif %}
+{%- endfor %}
 
 {% if dataclasses_json_annotation %}
 @dataclass_json(undefined=Undefined.EXCLUDE)

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

@@ -12,6 +12,38 @@ from avrotize.common import fullname, get_typing_args_from_string, is_generic_av
 
 INDENT = '    '
 
+# Python standard library modules that should not be shadowed by package names
+PYTHON_STDLIB_MODULES = {
+    'abc', 'aifc', 'argparse', 'array', 'ast', 'asynchat', 'asyncio', 'asyncore',
+    'atexit', 'audioop', 'base64', 'bdb', 'binascii', 'binhex', 'bisect', 'builtins',
+    'bz2', 'calendar', 'cgi', 'cgitb', 'chunk', 'cmath', 'cmd', 'code', 'codecs',
+    'codeop', 'collections', 'colorsys', 'compileall', 'concurrent', 'configparser',
+    'contextlib', 'contextvars', 'copy', 'copyreg', 'cProfile', 'crypt', 'csv',
+    'ctypes', 'curses', 'dataclasses', 'datetime', 'dbm', 'decimal', 'difflib',
+    'dis', 'distutils', 'doctest', 'email', 'encodings', 'enum', 'errno', 'faulthandler',
+    'fcntl', 'filecmp', 'fileinput', 'fnmatch', 'fractions', 'ftplib', 'functools',
+    'gc', 'getopt', 'getpass', 'gettext', 'glob', 'graphlib', 'grp', 'gzip',
+    'hashlib', 'heapq', 'hmac', 'html', 'http', 'imaplib', 'imghdr', 'imp',
+    'importlib', 'inspect', 'io', 'ipaddress', 'itertools', 'json', 'keyword',
+    'lib2to3', 'linecache', 'locale', 'logging', 'lzma', 'mailbox', 'mailcap',
+    'marshal', 'math', 'mimetypes', 'mmap', 'modulefinder', 'multiprocessing',
+    'netrc', 'nis', 'nntplib', 'numbers', 'operator', 'optparse', 'os', 'ossaudiodev',
+    'pathlib', 'pdb', 'pickle', 'pickletools', 'pipes', 'pkgutil', 'platform',
+    'plistlib', 'poplib', 'posix', 'posixpath', 'pprint', 'profile', 'pstats',
+    'pty', 'pwd', 'py_compile', 'pyclbr', 'pydoc', 'queue', 'quopri', 'random',
+    're', 'readline', 'reprlib', 'resource', 'rlcompleter', 'runpy', 'sched',
+    'secrets', 'select', 'selectors', 'shelve', 'shlex', 'shutil', 'signal',
+    'site', 'smtpd', 'smtplib', 'sndhdr', 'socket', 'socketserver', 'spwd',
+    'sqlite3', 'ssl', 'stat', 'statistics', 'string', 'stringprep', 'struct',
+    'subprocess', 'sunau', 'symtable', 'sys', 'sysconfig', 'syslog', 'tabnanny',
+    'tarfile', 'telnetlib', 'tempfile', 'termios', 'test', 'textwrap', 'threading',
+    'time', 'timeit', 'tkinter', 'token', 'tokenize', 'trace', 'traceback',
+    'tracemalloc', 'tty', 'turtle', 'turtledemo', 'types', 'typing', 'unicodedata',
+    'unittest', 'urllib', 'uu', 'uuid', 'venv', 'warnings', 'wave', 'weakref',
+    'webbrowser', 'winreg', 'winsound', 'wsgiref', 'xdrlib', 'xml', 'xmlrpc',
+    'zipapp', 'zipfile', 'zipimport', 'zlib', 'zoneinfo',
+}
+
 
 def is_python_reserved_word(word: str) -> bool:
     """Checks if a word is a Python reserved word"""
@@ -25,6 +57,13 @@ def is_python_reserved_word(word: str) -> bool:
     return word in reserved_words
 
 
+def safe_package_name(name: str) -> str:
+    """Converts a name to a safe Python package name that won't shadow stdlib"""
+    if name.lower() in PYTHON_STDLIB_MODULES:
+        return f"{name}_types"
+    return name
+
+
 class AvroToPython:
     """Converts Avro schema to Python data classes"""
 
@@ -167,6 +206,9 @@ class AvroToPython:
                 enum_ref = self.generate_enum(avro_type, parent_package, write_file=True)
                 import_types.add(enum_ref)
                 return self.strip_package_from_fully_qualified_name(enum_ref)
+            elif avro_type['type'] == 'fixed':
+                # Fixed types are represented as bytes in Python
+                return 'bytes'
             elif avro_type['type'] == 'array':
                 return f"typing.List[{self.convert_avro_type_to_python(avro_type['items'], parent_package, import_types)}]"
             elif avro_type['type'] == 'map':
@@ -611,6 +653,7 @@ def convert_avro_to_python(avro_schema_path, py_file_path, package_name='', data
     if not package_name:
         package_name = os.path.splitext(os.path.basename(avro_schema_path))[
             0].lower().replace('-', '_')
+    package_name = safe_package_name(package_name)
 
     avro_to_python = AvroToPython(
         package_name, dataclasses_json_annotation=dataclasses_json_annotation, avro_annotation=avro_annotation)
@@ -619,6 +662,7 @@ def convert_avro_to_python(avro_schema_path, py_file_path, package_name='', data
 
 def convert_avro_schema_to_python(avro_schema, py_file_path, package_name='', dataclasses_json_annotation=False, avro_annotation=False):
     """Converts Avro schema to Python data classes"""
+    package_name = safe_package_name(package_name) if package_name else package_name
     avro_to_python = AvroToPython(
         package_name, dataclasses_json_annotation=dataclasses_json_annotation, avro_annotation=avro_annotation)
     if isinstance(avro_schema, dict):

{avrotize-2.21.1 → avrotize-2.22.0}/avrotize/avrotorust/dataclass_enum.rs.jinja

@@ -55,20 +55,22 @@ mod tests {
     use super::*;
     use rand::Rng;
 
+    {%- if serde_annotation %}
     #[test]
     fn test_serialize_deserialize_{{ enum_name.lower() }}() {
         {%- for symbol in symbols %}
         let instance = {{ enum_name }}::{{ symbol }};
-        {%- if serde_annotation %}
         let json_bytes = serde_json::to_vec(&instance).unwrap();
         let deserialized_instance: {{ enum_name }} = serde_json::from_slice(&json_bytes).unwrap();
         assert_eq!(instance, deserialized_instance);
-        {%- endif %}
-        {%- if avro_annotation %}
-        let avro_bytes = instance.to_byte_array("avro/binary").unwrap();
-        let deserialized_avro_instance: {{ enum_name }} = {{ enum_name }}::from_data(&avro_bytes, "avro/binary").unwrap();
-        assert_eq!(instance, deserialized_avro_instance);
-        {%- endif %}
+        {%- endfor %}
+    }
+    {%- endif %}
+
+    #[test]
+    fn test_enum_variants_{{ enum_name.lower() }}() {
+        {%- for symbol in symbols %}
+        let _instance = {{ enum_name }}::{{ symbol }};
         {%- endfor %}
     }
 }

{avrotize-2.21.1 → avrotize-2.22.0}/avrotize/avrotorust/dataclass_struct.rs.jinja

@@ -4,28 +4,28 @@ use apache_avro::Schema;
 {%- endif %}
 {%- if serde_annotation or avro_annotation %}
 use serde::{Serialize, Deserialize};
-{%- endif %}
 use std::io::Write;
 use flate2::write::GzEncoder;
 use flate2::read::GzDecoder;
+{%- endif %}
 {%- set uses_chrono = false %}
 {%- set uses_uuid = false %}
 {%- set uses_hashmap = false%}
 {%- for field in fields %}
-{%- if field.type == "NaiveDate" or field.type == "NaiveTime" or field.type == "NaiveDateTime" %}
+{%- if field.type == "NaiveDate" or field.type == "NaiveTime" or field.type == "NaiveDateTime" or "chrono::" in field.type %}
 {%- set uses_chrono = true %}
 {%- endif %}
-{%- if field.type == "Uuid" %}
+{%- if field.type == "Uuid" or "uuid::" in field.type %}
 {%- set uses_uuid = true %}
 {%- endif %}
-{%- if field.type.startswith("HashMap<") %}
+{%- if field.type.startswith("HashMap<") or "HashMap<" in field.type %}
 {%- set uses_hashmap = true %}
 {%- endif %}
 {%- endfor %}
 {%- if uses_chrono %}
 use chrono::{NaiveDate, NaiveTime, NaiveDateTime};
 {%- endif %}
-{%- if uuid %}
+{%- if uses_uuid %}
 use uuid::Uuid;
 {%- endif %}
 {%- if uses_hashmap %}
@@ -39,7 +39,7 @@ use std::collections::HashMap;
 #[derive(Debug{%- if serde_annotation or avro_annotation %}, Serialize, Deserialize{%- endif %}, PartialEq, Clone, Default)]
 pub struct {{ struct_name }} {
 {%- for field in fields %}
-    {%- if field.serde_rename %}
+    {%- if field.serde_rename and (serde_annotation or avro_annotation) %}
     #[serde(rename = "{{ field.original_name }}")]
     {%- endif %}
     pub {{ field.name }}: {{ field.type }},
@@ -55,6 +55,7 @@ lazy_static! {
 {%- endif %}
 
 impl {{ struct_name }} {
+{%- if serde_annotation or avro_annotation %}
    /// Serializes the struct to a byte array based on the provided content type
     pub fn to_byte_array(&self, content_type: &str) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
         let result: Vec<u8>;
@@ -70,14 +71,10 @@ impl {{ struct_name }} {
             let value = apache_avro::to_value(self).unwrap();
             result = apache_avro::to_avro_datum(&SCHEMA, value).unwrap();
         }
-        {%- endif %}
-        {%- if avro_annotation or serde_annotation %}
+        else {% endif -%}
         {
-        {%- endif %}
             return Err(format!("unsupported media type: {}", media_type).into())
-        {%- if avro_annotation or serde_annotation %}
         }
-        {%- endif %}
         if media_type.ends_with("+gzip") {
             let mut encoder = GzEncoder::new(Vec::new(), flate2::Compression::default());
             encoder.write_all(&result)?;
@@ -87,7 +84,9 @@ impl {{ struct_name }} {
             return Ok(result)
         }
     }
+{%- endif %}
 
+{%- if serde_annotation or avro_annotation %}
     /// Deserializes the struct from a byte array based on the provided content type
     pub fn from_data(data: impl AsRef<[u8]>, content_type: &str) -> Result<Self, Box<dyn std::error::Error>> {
         let media_type = content_type.split(';').next().unwrap_or("");
@@ -114,7 +113,9 @@ impl {{ struct_name }} {
         {%- endif %}
         Err(format!("unsupported media type: {}", media_type).into())
     }
+{%- endif %}
 
+{%- if serde_annotation or avro_annotation %}
     /// Checks if the given JSON value matches the schema of the struct
     pub fn is_json_match(node: &serde_json::Value) -> bool {
         {%- for predicate in json_match_predicates %}
@@ -122,6 +123,7 @@ impl {{ struct_name }} {
         {%- endfor %}
         true
     }
+{%- endif %}
 
     /// Returns the struct instance itself
     pub fn to_object(&self) -> &Self {
@@ -160,6 +162,12 @@ mod tests {
         assert!(instance.{{ field.name }} != {{ field_type }}::default()); // Check that {{ field.name }} is not default
         {%- elif field.type.startswith("std::collections::HashMap<")%}
         assert!(instance.{{ field.name }}.len() >= 0); // Check that {{ field.name }} is not empty
+        {%- elif field.is_generated_type %}
+        // Skip default comparison for generated types (enums/unions) as random values may match default
+        let _ = &instance.{{ field.name }};
+        {%- elif field.type in ["i8", "i16", "i32", "i64", "u8", "u16", "u32", "u64", "f32", "f64", "isize", "usize"] %}
+        // Skip default comparison for numeric types as random values can legitimately be 0
+        let _ = instance.{{ field.name }};
         {%- elif field.type != "bool" %}
         assert!(instance.{{ field.name }} != {{ field.type }}::default()); // Check that {{ field.name }} is not default
         {%- endif %}

{avrotize-2.21.1 → avrotize-2.22.0}/avrotize/avrotorust/dataclass_union.rs.jinja

@@ -1,4 +1,4 @@
-{%- if serde_annotation %}
+{%- if serde_annotation or avro_annotation %}
 use serde::{self, Serialize, Deserialize};
 {%- endif %}
 
@@ -70,14 +70,25 @@ impl {{ union_enum_name }} {
 
 #[cfg(test)]
 impl {{ union_enum_name }} {
+{%- set unique_fields = union_fields | selectattr('is_first_with_predicate') | list %}
     pub fn generate_random_instance() -> {{ union_enum_name }} {
         let mut rng = rand::thread_rng();
+        {%- if serde_annotation and unique_fields | length < union_fields | length %}
+        // Only pick from variants with unique JSON structures to ensure round-trip works
+        match rand::Rng::gen_range(&mut rng, 0..{{ unique_fields | length }}) {
+            {%- for union_field in unique_fields %}
+            {{ loop.index0 }} => {{ union_enum_name }}::{{ union_field.name }}({{ union_field.random_value }}),
+            {%- endfor %}
+            _ => panic!("Invalid random index generated"),
+        }
+        {%- else %}
         match rand::Rng::gen_range(&mut rng, 0..{{ union_fields | length }}) {
             {%- for union_field in union_fields %}
             {{ loop.index0 }} => {{ union_enum_name }}::{{ union_field.name }}({{ union_field.random_value }}),
             {%- endfor %}
             _ => panic!("Invalid random index generated"),
         }
+        {%- endif %}
     }
 }
 
@@ -85,21 +96,28 @@ impl {{ union_enum_name }} {
 mod tests {
     use super::*;
 
+    {%- if serde_annotation %}
     #[test]
     fn test_serialize_deserialize_{{ union_enum_name.lower() }}() {
         let mut rng = rand::thread_rng();
         {%- for union_field in union_fields %}
+        {%- if union_field.is_first_with_predicate %}
         let instance = {{ union_enum_name }}::{{ union_field.name }}({{ union_field.random_value }});
-        {%- if serde_annotation %}
         let json_bytes = serde_json::to_vec(&instance).unwrap();
         let deserialized_instance: {{ union_enum_name }} = serde_json::from_slice(&json_bytes).unwrap();
         assert_eq!(instance, deserialized_instance);
+        {%- else %}
+        // Skip {{ union_field.name }} - structurally identical to earlier variant, would deserialize as first match
         {%- endif %}
-        {%- if avro_annotation %}
-        let avro_bytes = instance.to_byte_array("avro/binary").unwrap();
-        let deserialized_avro_instance: {{ union_enum_name }} = {{ union_enum_name }}::from_data(&avro_bytes, "avro/binary").unwrap();
-        assert_eq!(instance, deserialized_avro_instance);
-        {%- endif %}
+        {%- endfor %}
+    }
+    {%- endif %}
+
+    #[test]
+    fn test_union_variants_{{ union_enum_name.lower() }}() {
+        let mut rng = rand::thread_rng();
+        {%- for union_field in union_fields %}
+        let _instance = {{ union_enum_name }}::{{ union_field.name }}({{ union_field.random_value }});
         {%- endfor %}
     }
 }

{avrotize-2.21.1 → avrotize-2.22.0}/avrotize/avrotorust.py

@@ -144,12 +144,15 @@ class AvroToRust:
             field_name = self.safe_identifier(snake(original_field_name))
             field_type = self.convert_avro_type_to_rust(field_name, field['type'], parent_namespace)
             serde_rename = field_name != original_field_name
+            # Check if this is a generated type (enum, union, or record) where random values may match default
+            is_generated_type = field_type in self.generated_types_rust_package or '::' in field_type
             fields.append({
                 'original_name': original_field_name,
                 'name': field_name,
                 'type': field_type,
                 'serde_rename': serde_rename,
-                'random_value': self.generate_random_value(field_type)
+                'random_value': self.generate_random_value(field_type),
+                'is_generated_type': is_generated_type
             })
         
         struct_name = self.safe_identifier(pascal(avro_schema['name']))
@@ -187,28 +190,51 @@ class AvroToRust:
     def get_is_json_match_clause(self, field_name: str, field_type: str, for_union=False) -> str:
         """Generates the is_json_match clause for a field"""
         ref = f'node[\"{field_name}\"]' if not for_union else 'node'
-        if field_type == 'String' or field_type == 'Option<String>':
-            return f"{ref}.is_string()"
-        elif field_type == 'bool' or field_type == 'Option<bool>':
-            return f"{ref}.is_boolean()"
-        elif field_type == 'i32' or field_type == 'Option<i32>':
-            return f"{ref}.is_i64()"
-        elif field_type == 'i64' or field_type == 'Option<i64>':
-            return f"{ref}.is_i64()"
-        elif field_type == 'f32' or field_type == 'Option<f32>':
-            return f"{ref}.is_f64()"
-        elif field_type == 'f64' or field_type == 'Option<f64>':
-            return f"{ref}.is_f64()"
-        elif field_type == 'Vec<u8>' or field_type == 'Option<Vec<u8>>':
-            return f"{ref}.is_array()"
-        elif field_type == 'serde_json::Value' or field_type == 'std::collections::HashMap<String, String>':
-            return f"{ref}.is_object()"
-        elif field_type.startswith('std::collections::HashMap<String, '):
-            return f"{ref}.is_object()"
-        elif field_type.startswith('Vec<'):
-            return f"{ref}.is_array()"
+        
+        # Check if type is optional - if so, we need to allow null values
+        is_optional = field_type.startswith('Option<')
+        base_type = field_type[7:-1] if is_optional else field_type
+        null_check = f" || {ref}.is_null()" if is_optional else ""
+        
+        # serde_json::Value can be any JSON type, so always return true
+        if base_type == 'serde_json::Value':
+            return "true"
+        
+        if base_type == 'String':
+            return f"({ref}.is_string(){null_check})"
+        elif base_type == 'bool':
+            return f"({ref}.is_boolean(){null_check})"
+        elif base_type == 'i32':
+            return f"({ref}.is_i64(){null_check})"
+        elif base_type == 'i64':
+            return f"({ref}.is_i64(){null_check})"
+        elif base_type == 'f32':
+            return f"({ref}.is_f64(){null_check})"
+        elif base_type == 'f64':
+            return f"({ref}.is_f64(){null_check})"
+        elif base_type == 'Vec<u8>':
+            return f"({ref}.is_array(){null_check})"
+        elif base_type == 'std::collections::HashMap<String, String>':
+            return f"({ref}.is_object(){null_check})"
+        elif base_type.startswith('std::collections::HashMap<String, '):
+            return f"({ref}.is_object(){null_check})"
+        elif base_type.startswith('Vec<'):
+            return f"({ref}.is_array(){null_check})"
+        # chrono types - check for string (ISO 8601 format) or number (timestamp)
+        elif 'chrono::NaiveDateTime' in base_type or 'NaiveDateTime' in base_type:
+            return f"({ref}.is_string() || {ref}.is_i64(){null_check})"
+        elif 'chrono::NaiveDate' in base_type or 'NaiveDate' in base_type:
+            return f"({ref}.is_string() || {ref}.is_i64(){null_check})"
+        elif 'chrono::NaiveTime' in base_type or 'NaiveTime' in base_type:
+            return f"({ref}.is_string() || {ref}.is_i64(){null_check})"
+        # uuid type - check for string
+        elif 'uuid::Uuid' in base_type or 'Uuid' in base_type:
+            return f"({ref}.is_string(){null_check})"
         else:
-            return f"{field_type}::is_json_match(&{ref})"
+            # Custom types - call their is_json_match method
+            if is_optional:
+                return f"({base_type}::is_json_match(&{ref}) || {ref}.is_null())"
+            return f"{base_type}::is_json_match(&{ref})"
 
 
     def generate_enum(self, avro_schema: Dict, parent_namespace: str) -> str:
@@ -250,17 +276,29 @@ class AvroToRust:
         ns = namespace.replace('.', '::').lower()
         union_enum_name = pascal(field_name) + 'Union'
         union_types = [self.convert_avro_type_to_rust(field_name + "Option" + str(i), t, namespace) for i, t in enumerate(avro_type) if t != 'null']
-        union_fields = [
-            {
+        
+        # Track seen predicates to identify structurally identical variants
+        seen_predicates: set = set()
+        union_fields = []
+        for i, t in enumerate(union_types):
+            predicate = self.get_is_json_match_clause(field_name, t, for_union=True)
+            # Mark if this is the first variant with this predicate structure
+            # Subsequent variants with same predicate can't be distinguished during JSON deserialization
+            is_first_with_predicate = predicate not in seen_predicates
+            seen_predicates.add(predicate)
+            union_fields.append({
                 'name': pascal(t.rsplit('::',1)[-1]), 
                 'type': t, 
                 'random_value': self.generate_random_value(t),
                 'default_value': 'Default::default()',
-                'json_match_predicate': self.get_is_json_match_clause(field_name, t, for_union=True),
-            } for i, t in enumerate(union_types)]
+                'json_match_predicate': predicate,
+                'is_first_with_predicate': is_first_with_predicate,
+            })
+        
         qualified_union_enum_name = self.safe_package(self.concat_package(ns, union_enum_name))
         context = {
             'serde_annotation': self.serde_annotation,
+            'avro_annotation': self.avro_annotation,
             'union_enum_name': union_enum_name,
             'union_fields': union_fields,
             'json_match_predicates': [self.get_is_json_match_clause(f['name'], f['type'], for_union=True) for f in union_fields]