fix: Get enum default from parent schema

Author: Constantinos Symeonides

openapi_python_client/parser/properties/__init__.py

@@ -8,7 +8,7 @@
 from ..errors import PropertyError, ValidationError
 from ..reference import Reference
 from .converter import convert, convert_chain
-from .enum_property import EnumProperty
+from .enum_property import EnumProperty, ValueType
 from .model_property import ModelProperty, build_model_property
 from .property import Property
 from .schemas import Schemas
@@ -305,32 +305,40 @@ def build_enum_property(
     else:
         return PropertyError(data=data, detail="No values provided for Enum"), schemas
 
-    default = None
-    if data.default is not None:
-        inverse_values = {v: k for k, v in values.items()}
-        try:
-            default = f"{reference.class_name}.{inverse_values[data.default]}"
-        except KeyError:
-            return (
-                PropertyError(
-                    detail=f"{data.default} is an invalid default for enum {reference.class_name}", data=data
-                ),
-                schemas,
-            )
-
     prop = EnumProperty(
         name=name,
         required=required,
-        default=default,
         nullable=data.nullable,
         reference=reference,
         values=values,
         value_type=value_type,
+        default=None,
     )
+
+    default = get_enum_default(prop, data)
+    if isinstance(default, PropertyError):
+        return default, schemas
+    prop = attr.evolve(prop, default=default)
+
     schemas = attr.evolve(schemas, enums={**schemas.enums, prop.reference.class_name: prop})
     return prop, schemas
 
 
+def get_enum_default(prop: EnumProperty, data: oai.Schema) -> Union[Optional[Any], PropertyError]:
+    if data.default is None:
+        return None
+
+    inverse_values = {v: k for k, v in prop.values.items()}
+    try:
+        return f"{prop.reference.class_name}.{inverse_values[data.default]}"
+    except KeyError:
+        return (
+            PropertyError(
+                detail=f"{data.default} is an invalid default for enum {prop.reference.class_name}", data=data
+            )
+        )
+
+
 def build_union_property(
     *, data: oai.Schema, name: str, required: bool, schemas: Schemas, parent_name: str
 ) -> Tuple[Union[UnionProperty, PropertyError], Schemas]:
@@ -381,18 +389,25 @@ def build_list_property(
 def _property_from_ref(
     name: str,
     required: bool,
-    nullable: bool,
+    parent: Union[oai.Schema, None],
     data: oai.Reference,
     schemas: Schemas,
 ) -> Tuple[Union[Property, PropertyError], Schemas]:
     reference = Reference.from_ref(data.ref)
     existing = schemas.enums.get(reference.class_name) or schemas.models.get(reference.class_name)
-    if existing:
-        return (
-            attr.evolve(existing, required=required, name=name, nullable=nullable),
-            schemas,
-        )
-    return PropertyError(data=data, detail="Could not find reference in parsed models or enums"), schemas
+    if not existing:
+        return PropertyError(data=data, detail="Could not find reference in parsed models or enums"), schemas
+
+    prop = attr.evolve(existing, required=required, name=name)
+    if parent:
+        prop = attr.evolve(prop, nullable=parent.nullable)
+        if isinstance(prop, EnumProperty):
+            default = get_enum_default(prop, parent)
+            if isinstance(default, PropertyError):
+                return default, schemas
+            prop = attr.evolve(prop, default=default)
+
+    return prop, schemas
 
 
 def _property_from_data(
@@ -405,21 +420,21 @@ def _property_from_data(
     """ Generate a Property from the OpenAPI dictionary representation of it """
     name = utils.remove_string_escapes(name)
     if isinstance(data, oai.Reference):
-        return _property_from_ref(name=name, required=required, nullable=False, data=data, schemas=schemas)
+        return _property_from_ref(name=name, required=required, parent=None, data=data, schemas=schemas)
 
     sub_data = (data.allOf or []) + data.anyOf + data.oneOf
     if len(sub_data) == 1 and isinstance(sub_data[0], oai.Reference):
         return _property_from_ref(
-            name=name, required=required, nullable=data.nullable, data=sub_data[0], schemas=schemas
+            name=name, required=required, parent=data, data=sub_data[0], schemas=schemas
         )
 
     if data.enum:
         return build_enum_property(
             data=data, name=name, required=required, schemas=schemas, enum=data.enum, parent_name=parent_name
         )
-    if data.anyOf or data.oneOf:
+    elif data.anyOf or data.oneOf:
         return build_union_property(data=data, name=name, required=required, schemas=schemas, parent_name=parent_name)
-    if data.type == "string":
+    elif data.type == "string":
         return _string_based_property(name=name, required=required, data=data), schemas
     elif data.type == "number":
         return (
@@ -460,6 +475,10 @@ def _property_from_data(
     return PropertyError(data=data, detail=f"unknown type {data.type}"), schemas
 
 
+def _merge_properties(data: oai.Schema, prop: Property) -> Property:
+    return attr.evolve(prop, default=get_enum_default(data, prop.reference, prop.values))
+
+
 def property_from_data(
     *,
     name: str,

tests/test_parser/test_properties/test_init.py

@@ -624,6 +624,85 @@ def test_property_from_data_ref_enum(self):
         )
         assert schemas == new_schemas
 
+    def test_property_from_data_ref_enum_with_overridden_default(self):
+        from openapi_python_client.parser.properties import EnumProperty, Reference, Schemas, property_from_data
+
+        name = "some_enum"
+        data = oai.Schema.construct(default="b", allOf=[oai.Reference.construct(ref="MyEnum")])
+        existing_enum = EnumProperty(
+            name="an_enum",
+            required=True,
+            nullable=False,
+            default="MyEnum.A",
+            values={"A": "a", "B": "b"},
+            value_type=str,
+            reference=Reference(class_name="MyEnum", module_name="my_enum"),
+        )
+        schemas = Schemas(enums={"MyEnum": existing_enum})
+
+        prop, new_schemas = property_from_data(name=name, required=False, data=data, schemas=schemas, parent_name="")
+
+        assert prop == EnumProperty(
+            name="some_enum",
+            required=False,
+            nullable=False,
+            default="MyEnum.B",
+            values={"A": "a", "B": "b"},
+            value_type=str,
+            reference=Reference(class_name="MyEnum", module_name="my_enum"),
+        )
+        assert schemas == new_schemas
+
+    def test_property_from_data_ref_enum_with_overridden_default(self):
+        from openapi_python_client.parser.properties import EnumProperty, Reference, Schemas, property_from_data
+
+        name = "some_enum"
+        data = oai.Schema.construct(default="b", allOf=[oai.Reference.construct(ref="MyEnum")])
+        existing_enum = EnumProperty(
+            name="an_enum",
+            required=True,
+            nullable=False,
+            default="MyEnum.A",
+            values={"A": "a", "B": "b"},
+            value_type=str,
+            reference=Reference(class_name="MyEnum", module_name="my_enum"),
+        )
+        schemas = Schemas(enums={"MyEnum": existing_enum})
+
+        prop, new_schemas = property_from_data(name=name, required=False, data=data, schemas=schemas, parent_name="")
+
+        assert prop == EnumProperty(
+            name="some_enum",
+            required=False,
+            nullable=False,
+            default="MyEnum.B",
+            values={"A": "a", "B": "b"},
+            value_type=str,
+            reference=Reference(class_name="MyEnum", module_name="my_enum"),
+        )
+        assert schemas == new_schemas
+
+    def test_property_from_data_ref_enum_with_invalid_default(self):
+        from openapi_python_client.parser.properties import EnumProperty, Reference, Schemas, property_from_data
+
+        name = "some_enum"
+        data = oai.Schema.construct(default="x", allOf=[oai.Reference.construct(ref="MyEnum")])
+        existing_enum = EnumProperty(
+            name="an_enum",
+            required=True,
+            nullable=False,
+            default="MyEnum.A",
+            values={"A": "a", "B": "b"},
+            value_type=str,
+            reference=Reference(class_name="MyEnum", module_name="my_enum"),
+        )
+        schemas = Schemas(enums={"MyEnum": existing_enum})
+
+        prop, new_schemas = property_from_data(name=name, required=False, data=data, schemas=schemas, parent_name="")
+
+        assert schemas == new_schemas
+        assert prop == PropertyError(data=data, detail="x is an invalid default for enum MyEnum")
+
     def test_property_from_data_ref_model(self):
         from openapi_python_client.parser.properties import ModelProperty, Reference, Schemas, property_from_data