Validate all default types

Author: dbanty

openapi_python_client/parser/properties/enum_property.py

@@ -164,6 +164,12 @@ def convert_value(self, value: Any) -> Value | PropertyError | None:
                 return PropertyError(detail=f"Value {value} is not valid for enum {self.name}")
         return PropertyError(detail=f"Cannot convert {value} to enum {self.name} of type {self.value_type}")
 
+    def default_to_raw(self) -> ValueType | None:
+        if self.default is None:
+            return None
+        key = self.default.split(".")[1]
+        return self.values[key]
+
     def get_base_type_string(self, *, quoted: bool = False) -> str:
         return self.class_info.name
 

openapi_python_client/parser/properties/merge_properties.py

@@ -9,12 +9,11 @@
 from ..errors import PropertyError
 from . import FloatProperty
 from .any import AnyProperty
-from .enum_property import EnumProperty, ValueType
+from .enum_property import EnumProperty
 from .int import IntProperty
 from .list_property import ListProperty
 from .property import Property
 from .protocol import PropertyProtocol
-from .schemas import Class
 from .string import StringProperty
 
 PropertyT = TypeVar("PropertyT", bound=PropertyProtocol)
@@ -81,31 +80,25 @@ def _merge_same_type(prop1: Property, prop2: Property) -> Property | None | Prop
     return _merge_common_attributes(prop1, prop2)
 
 
-def _merge_string(prop1: StringProperty, prop2: StringProperty) -> StringProperty:
+def _merge_string(prop1: StringProperty, prop2: StringProperty) -> StringProperty | PropertyError:
     return _merge_common_attributes(prop1, prop2)
 
 
 def _merge_numeric(prop1: Property, prop2: Property) -> IntProperty | None | PropertyError:
     """Merge IntProperty with FloatProperty"""
     if isinstance(prop1, IntProperty) and isinstance(prop2, (IntProperty, FloatProperty)):
-        result = _merge_common_attributes(prop1, prop2)
+        return _merge_common_attributes(prop1, prop2)
     elif isinstance(prop2, IntProperty) and isinstance(prop1, (IntProperty, FloatProperty)):
         # Use the IntProperty as a base since it's more restrictive, but keep the correct override order
-        result = _merge_common_attributes(prop2, prop1, prop2)
+        return _merge_common_attributes(prop2, prop1, prop2)
     else:
         return None
-    if result.default is not None:
-        if isinstance(result.default, float) and not result.default.is_integer():
-            return PropertyError(detail=f"default value {result.default} is not valid for an integer property")
-    return result
 
 
 def _merge_with_enum(prop1: PropertyProtocol, prop2: PropertyProtocol) -> EnumProperty | PropertyError:
     if isinstance(prop1, EnumProperty) and isinstance(prop2, EnumProperty):
         # We want the narrowest validation rules that fit both, so use whichever values list is a
         # subset of the other.
-        values: dict[str, ValueType]
-        class_info: Class
         if _values_are_subset(prop1, prop2):
             values = prop1.values
             class_info = prop1.class_info
@@ -128,7 +121,7 @@ def _merge_with_enum(prop1: PropertyProtocol, prop2: PropertyProtocol) -> EnumPr
     )
 
 
-def _merge_common_attributes(base: PropertyT, *extend_with: PropertyProtocol) -> PropertyT:
+def _merge_common_attributes(base: PropertyT, *extend_with: PropertyProtocol) -> PropertyT | PropertyError:
     """Create a new instance based on base, overriding basic attributes with values from extend_with, in order.
 
     For "default", "description", and "example", a non-None value overrides any value from a previously
@@ -140,10 +133,16 @@ def _merge_common_attributes(base: PropertyT, *extend_with: PropertyProtocol) ->
     """
     current = base
     for override in extend_with:
+        if isinstance(override, EnumProperty):
+            override_default = current.convert_value(override.default_to_raw())
+        else:
+            override_default = current.convert_value(override.default)
+        if isinstance(override_default, PropertyError):
+            return override_default
         current = evolve(
             current,  # type: ignore # can't prove that every property type is an attrs class, but it is
             required=current.required or override.required,
-            default=override.default or current.default,
+            default=override_default or current.default,
             description=override.description or current.description,
             example=override.example or current.example,
         )

tests/test_parser/test_properties/test_merge_properties.py

@@ -21,10 +21,10 @@ def test_merge_basic_attributes_same_type(
     model_property_factory,
 ):
     basic_props = [
-        boolean_property_factory(default=True),
-        int_property_factory(default=1),
-        float_property_factory(default=1.5),
-        string_property_factory(default="x"),
+        boolean_property_factory(default="True"),
+        int_property_factory(default="1"),
+        float_property_factory(default="1.5"),
+        string_property_factory(default=StringProperty.convert_value("x")),
         list_property_factory(),
         model_property_factory(),
     ]
@@ -68,17 +68,17 @@ def test_incompatible_types(
 
 def test_merge_int_with_float(int_property_factory, float_property_factory):
     int_prop = int_property_factory(description="desc1")
-    float_prop = float_property_factory(default=2, description="desc2")
+    float_prop = float_property_factory(default="2", description="desc2")
 
     assert merge_properties(int_prop, float_prop) == (
         evolve(int_prop, default=float_prop.default, description=float_prop.description)
     )
     assert merge_properties(float_prop, int_prop) == (evolve(int_prop, default=float_prop.default))
 
-    float_prop_with_non_int_default = evolve(float_prop, default=2.5)
+    float_prop_with_non_int_default = evolve(float_prop, default="2.5")
     error = merge_properties(int_prop, float_prop_with_non_int_default)
     assert isinstance(error, PropertyError), "Expected invalid default to error"
-    assert "default value" in error.detail
+    assert error.detail == "Invalid int value: 2.5"
 
 
 def test_merge_with_any(
@@ -91,17 +91,16 @@ def test_merge_with_any(
 ):
     original_desc = "description"
     props = [
-        boolean_property_factory(default=True, description=original_desc),
-        int_property_factory(default=1, description=original_desc),
-        float_property_factory(default=1.5, description=original_desc),
-        string_property_factory(default="x", description=original_desc),
+        boolean_property_factory(default="True", description=original_desc),
+        int_property_factory(default="1", description=original_desc),
+        float_property_factory(default="1.5", description=original_desc),
+        string_property_factory(default=StringProperty.convert_value("x"), description=original_desc),
         model_property_factory(description=original_desc),
     ]
     any_prop = any_property_factory()
     for prop in props:
-        expected_result = evolve(prop, description=original_desc, default=prop.default)
-        assert merge_properties(any_prop, prop) == expected_result
-        assert merge_properties(prop, any_prop) == expected_result
+        assert merge_properties(any_prop, prop) == prop
+        assert merge_properties(prop, any_prop) == prop
 
 
 def test_merge_enums(enum_property_factory, config):
@@ -134,9 +133,9 @@ def test_merge_enums(enum_property_factory, config):
 
 def test_merge_string_with_string_enum(string_property_factory, enum_property_factory):
     values = {"A": "A", "B": "B"}
-    string_prop = string_property_factory(default="default1", description="desc1", example="example1")
+    string_prop = string_property_factory(default="A", description="desc1", example="example1")
     enum_prop = enum_property_factory(
-        default="default2",
+        default="test.B",
         description="desc2",
         example="example2",
         values=values,
@@ -147,17 +146,17 @@ def test_merge_string_with_string_enum(string_property_factory, enum_property_fa
     assert merge_properties(enum_prop, string_prop) == evolve(
         enum_prop,
         required=True,
-        default=string_prop.default,
+        default="test.A",
         description=string_prop.description,
         example=string_prop.example,
     )
 
 
 def test_merge_int_with_int_enum(int_property_factory, enum_property_factory):
     values = {"VALUE_1": 1, "VALUE_2": 2}
-    int_prop = int_property_factory(default=100, description="desc1", example="example1")
+    int_prop = int_property_factory(default=1, description="desc1", example="example1")
     enum_prop = enum_property_factory(
-        default=200,
+        default="test.VALUE_1",
         description="desc2",
         example="example2",
         values=values,
@@ -166,7 +165,7 @@ def test_merge_int_with_int_enum(int_property_factory, enum_property_factory):
 
     assert merge_properties(int_prop, enum_prop) == evolve(enum_prop, required=True)
     assert merge_properties(enum_prop, int_prop) == evolve(
-        enum_prop, required=True, default=int_prop.default, description=int_prop.description, example=int_prop.example
+        enum_prop, required=True, description=int_prop.description, example=int_prop.example
     )
 
 

tests/test_parser/test_properties/test_model_property.py

@@ -403,25 +403,6 @@ def test_reference_not_processed(self, model_property_factory, config):
 
         assert isinstance(result, PropertyError)
 
-    def test_conflicting_properties_same_types(self, model_property_factory, string_property_factory, config):
-        data = oai.Schema.model_construct(
-            allOf=[oai.Reference.model_construct(ref="#/First"), oai.Reference.model_construct(ref="#/Second")]
-        )
-        schemas = Schemas(
-            classes_by_reference={
-                "/First": model_property_factory(
-                    required_properties=[], optional_properties=[string_property_factory(default="abc")]
-                ),
-                "/Second": model_property_factory(
-                    required_properties=[], optional_properties=[string_property_factory(default="def")]
-                ),
-            }
-        )
-
-        result = _process_properties(data=data, schemas=schemas, class_name="", config=config, roots={"root"})
-
-        assert isinstance(result, PropertyError)
-
     def test_allof_string_and_string_enum(
         self, model_property_factory, enum_property_factory, string_property_factory, config
     ):