Merge pull request #5 from marcosschroh/fix/factory-pattern

ref: Factory pattern implemented.

Author: marcosschroh

dataclasses_avroschema/fields.py

@@ -65,37 +65,51 @@ def __post_init__(self):
         if isinstance(self.type, typing._GenericAlias):
             # means that could be a list, tuple or dict
             origin = self.type.__origin__
-
-            if origin is list:
-                # because avro can have only one type, we take the first one
-                items_type = self.type.__args__[0]
-
-                if items_type in PYTHON_PRIMITIVE_TYPES:
-                    self.items_type = PYTHON_TYPE_TO_AVRO[items_type]
-                else:
-                    # means is a custom type
-                    self.items_type = schema_generator.SchemaGenerator(
-                        items_type).avro_schema_to_python()
-            elif origin is dict:
-                # because avro can have only one type, we take the first one
-                values_type = self.type.__args__[1]
-
-                if values_type in PYTHON_PRIMITIVE_TYPES:
-                    self.values_type = PYTHON_TYPE_TO_AVRO[values_type]
-                else:
-                    self.values_type = schema_generator.SchemaGenerator(
-                        values_type).avro_schema_to_python()
-
-            elif origin is tuple:
-                self.symbols = list(self.default)
-            else:
-                # we do not accept any other typing._GenericAlias like a set
-                # we should raise an exception
-                raise ValueError(
-                    f"Invalid Type for field {self.name}. Accepted types are list, tuple or dict")
+            processor = self.get_processor(origin)
+            processor()
 
             self.type = origin
 
+    def get_processor(self, origin):
+        if origin is list:
+            return self._process_list_type
+        elif origin is dict:
+            return self._process_dict_type
+        elif origin is tuple:
+            return self._process_tuple_type
+        else:
+            # we do not accept any other typing._GenericAlias like a set
+            # we should raise an exception
+            raise ValueError(
+                f"Invalid Type for field {self.name}. Accepted types are list, tuple or dict")
+
+    def _process_list_type(self):
+        # because avro can have only one type, we take the first one
+        items_type = self.type.__args__[0]
+
+        if items_type in PYTHON_PRIMITIVE_TYPES:
+            self.items_type = PYTHON_TYPE_TO_AVRO[items_type]
+        elif isinstance(items_type, typing._GenericAlias):
+            # Checking for a self reference. Maybe is a typing.ForwardRef
+            self.items_type = self._process_self_reference_type(items_type)
+        else:
+            # means is a custom type
+            self.items_type = schema_generator.SchemaGenerator(
+                items_type).avro_schema_to_python()
+
+    def _process_dict_type(self):
+        # because avro can have only one type, we take the first one
+        values_type = self.type.__args__[1]
+
+        if values_type in PYTHON_PRIMITIVE_TYPES:
+            self.values_type = PYTHON_TYPE_TO_AVRO[values_type]
+        else:
+            self.values_type = schema_generator.SchemaGenerator(
+                values_type).avro_schema_to_python()
+
+    def _process_tuple_type(self):
+        self.symbols = list(self.default)
+
     @staticmethod
     def get_singular_name(name):
         singular = p.singular_noun(name)

dataclasses_avroschema/schema_definition.py

@@ -43,12 +43,6 @@ def __post_init__(self):
         self.generate_extra_avro_attributes()
         self.fields = self.parse_dataclasses_fields()
 
-    # def parse_dataclasses_fields(self) -> typing.List["Field"]:
-    #     return [
-    #         fields.Field(dataclass_field.name, dataclass_field.type, dataclass_field.default)
-    #         for dataclass_field in dataclasses.fields(self.klass_or_instance)
-    #     ]
-
     def parse_dataclasses_fields(self) -> typing.List["fields.Field"]:
         return [
             fields.Field(

dataclasses_avroschema/schema_generator.py

@@ -23,17 +23,22 @@ def generate_schema(self, schema_type: str = "avro"):
             return self.schema_definition
 
         if schema_type == "avro":
-            # cache the schema
-            self.schema_definition = AvroSchemaDefinition(
-                "record",
-                self.dataclass,
-                include_schema_doc=self.include_schema_doc
-            )
+            schema_definition = self._generate_avro_schema()
         else:
-            raise
+            raise ValueError("Invalid type. Expected avro schema type.")
+
+        # cache the schema
+        self.schema_definition = schema_definition
 
         return self.schema_definition.render()
 
+    def _generate_avro_schema(self) -> AvroSchemaDefinition:
+        return AvroSchemaDefinition(
+            "record",
+            self.dataclass,
+            include_schema_doc=self.include_schema_doc
+        )
+
     def avro_schema(self) -> str:
         return json.dumps(self.generate_schema(schema_type="avro"))
 
@@ -46,4 +51,3 @@ def get_fields(self) -> typing.List["Field"]:
             self.generate_schema()
 
         return self.schema_definition.fields
-

tests/test_schema.py

@@ -114,3 +114,9 @@ def extra_avro_attributes():
     msg = "Dict must be returned type in extra_avro_attributes method"
     with pytest.raises(AssertionError, match=msg):
         SchemaGenerator(User).avro_schema()
+
+
+def test_invalid_schema_type(user_dataclass):
+    msg = "Invalid type. Expected avro schema type."
+    with pytest.raises(ValueError, match=msg):
+        SchemaGenerator(user_dataclass).generate_schema(schema_type="json")

tests/test_schema_parse.py

@@ -79,7 +79,7 @@ class UserAdvance:
     assert parse_schema(schema.avro_schema_to_python())
 
 
-def test_one_to_one_schema(user_advance_with_defaults_dataclass):
+def test_one_to_one_schema():
     """
     Test schema relationship one-to-one
     """
@@ -97,7 +97,7 @@ class User:
     assert parse_schema(SchemaGenerator(User).avro_schema_to_python())
 
 
-def test_one_to_many_schema(user_advance_with_defaults_dataclass):
+def test_one_to_many_schema():
     """
     Test schema relationship one-to-many
     """
@@ -115,7 +115,7 @@ class User:
     assert parse_schema(SchemaGenerator(User).avro_schema_to_python())
 
 
-def test_one_to_many_with_map_schema(user_advance_with_defaults_dataclass):
+def test_one_to_many_with_map_schema():
     """
     Test schema relationship one-to-many using a map
     """