misc fixes

eli-bl · eli-bl · commit c4dda2c140d5 · 2024-11-18T11:01:18.000-08:00
diff --git a/end_to_end_tests/functional_tests/generated_code_execution/test_defaults.py b/end_to_end_tests/functional_tests/generated_code_execution/test_defaults.py
@@ -112,3 +112,35 @@ def test_enum_default(self, MyEnum, MyModel):
 class TestLiteralEnumDefaults:
     def test_default_value(self, MyModel):
         assert MyModel().enum_prop == "A"
+
+
+@with_generated_client_fixture(
+"""
+# Test the ability to specify a default value for a union type as long as that value is
+# supported by at least one of the variants
+
+components:
+  schemas:
+    MyModel:
+      type: object
+      properties:
+        simpleTypeProp1:
+          type: ["integer", "boolean", "string"]
+          default: 3
+        simpleTypeProp2:
+          type: ["integer", "boolean", "string"]
+          default: true
+        simpleTypeProp3:
+          type: ["integer", "boolean", "string"]
+          default: abc
+"""
+)
+@with_generated_code_imports(".models.MyModel")
+class TestUnionDefaults:
+    def test_simple_type(self, MyModel):
+        instance = MyModel()
+        assert instance == MyModel(
+            simple_type_prop_1=3,
+            simple_type_prop_2=True,
+            simple_type_prop_3="abc",
+        )
diff --git a/end_to_end_tests/functional_tests/generated_code_execution/test_unions.py b/end_to_end_tests/functional_tests/generated_code_execution/test_unions.py
@@ -10,32 +10,6 @@
 )
 
 
-@with_generated_client_fixture(
-"""
-components:
-  schemas:
-    StringOrInt:
-      type: ["string", "integer"]
-    MyModel:
-      type: object
-      properties:
-        stringOrIntProp:
-          type: ["string", "integer"]
-"""
-)
-@with_generated_code_imports(
-    ".models.MyModel",
-    ".types.Unset"
-)
-class TestSimpleTypeList:
-    def test_decode_encode(self, MyModel):
-        assert_model_decode_encode(MyModel, {"stringOrIntProp": "a"}, MyModel(string_or_int_prop="a"))
-        assert_model_decode_encode(MyModel, {"stringOrIntProp": 1}, MyModel(string_or_int_prop=1))
-
-    def test_type_hints(self, MyModel, Unset):
-        assert_model_property_type_hint(MyModel, "string_or_int_prop", Union[str, int, Unset])
-
-
 @with_generated_client_fixture(
 """
 # Various use cases for oneOf
@@ -271,88 +245,8 @@ def test_type_hints(self, MyModel, MyEnum, MyEnumIncludingNull, Unset):
 
 @with_generated_client_fixture(
 """
-# Test use cases where there's a union of types *and* an explicit list of multiple "type:"s
+# Tests for using a discriminator property
 
-components:
-  schemas:
-    MyStringEnum:
-      type: string
-      enum: ["a", "b"]
-    MyIntEnum:
-      type: integer
-      enum: [1, 2]
-    MyEnumIncludingNull:
-      type: ["string", "null"]
-      enum: ["a", "b", null]
-    MyObject:
-      type: object
-      properties:
-        name:
-          type: string
-    MyModel:
-      properties:
-        enumsWithListOfTypesProp:
-          type: ["string", "integer"]
-          oneOf:
-            - {"$ref": "#/components/schemas/MyStringEnum"}
-            - {"$ref": "#/components/schemas/MyIntEnum"}
-        enumIncludingNullProp: {"$ref": "#/components/schemas/MyEnumIncludingNull"}
-        nullableObjectWithListOfTypesProp:
-          type: ["string", "object"]
-          oneOf:
-            - {"$ref": "#/components/schemas/MyObject"}
-            - type: "null"
-""")
-@with_generated_code_imports(
-    ".models.MyStringEnum",
-    ".models.MyIntEnum",
-    ".models.MyEnumIncludingNull",
-    ".models.MyObject",
-    ".models.MyModel",
-    ".types.Unset",
-)
-class TestUnionsWithExplicitListOfTypes:
-    # This covers some use cases where combining "oneOf" with "type: [list of types]" (which is fine
-    # to do in OpenAPI) used to generate enum/model classes incorrectly.
-
-    def test_union_of_enums(self, MyModel, MyStringEnum, MyIntEnum):
-        assert_model_decode_encode(
-            MyModel,
-            {"enumsWithListOfTypesProp": "b"},
-            MyModel(enums_with_list_of_types_prop=MyStringEnum.B),
-        )
-        assert_model_decode_encode(
-            MyModel,
-            {"enumsWithListOfTypesProp": 2},
-            MyModel(enums_with_list_of_types_prop=MyIntEnum.VALUE_2),
-        )
-
-    def test_union_of_enum_with_null(self, MyModel, MyEnumIncludingNull):
-        assert_model_decode_encode(
-            MyModel,
-            {"enumIncludingNullProp": "b"},
-            MyModel(enum_including_null_prop=MyEnumIncludingNull.B),
-        )
-        assert_model_decode_encode(
-            MyModel,
-            {"enumIncludingNullProp": None},
-            MyModel(enum_including_null_prop=None),
-        )
-
-    def test_nullable_object_with_list_of_types(self, MyModel, MyObject):
-        assert_model_decode_encode(
-            MyModel,
-            {"nullableObjectWithListOfTypesProp": {"name": "a"}},
-            MyModel(nullable_object_with_list_of_types_prop=MyObject(name="a")),
-        )
-        assert_model_decode_encode(
-            MyModel,
-            {"nullableObjectWithListOfTypesProp": None},
-            MyModel(nullable_object_with_list_of_types_prop=None),
-        )
-    
-@with_generated_client_fixture(
-"""
 components:
   schemas:
     ModelType1:
@@ -503,3 +397,112 @@ def test_nested_with_different_property(self, ModelType1, Schnauzer, WithNestedD
             {"unionProp": {"modelType": "irrelevant", "dogType": "Schnauzer", "name": "a"}},
             WithNestedDiscriminatorsDifferentProperty(union_prop=Schnauzer(model_type="irrelevant", dog_type="Schnauzer", name="a")),
         )
+
+
+@with_generated_client_fixture(
+"""
+# Tests for using multiple values of "type:" in one schema (OpenAPI 3.1)
+
+components:
+  schemas:
+    StringOrInt:
+      type: ["string", "integer"]
+    MyModel:
+      type: object
+      properties:
+        stringOrIntProp:
+          type: ["string", "integer"]
+"""
+)
+@with_generated_code_imports(
+    ".models.MyModel",
+    ".types.Unset"
+)
+class TestListOfSimpleTypes:
+    def test_decode_encode(self, MyModel):
+        assert_model_decode_encode(MyModel, {"stringOrIntProp": "a"}, MyModel(string_or_int_prop="a"))
+        assert_model_decode_encode(MyModel, {"stringOrIntProp": 1}, MyModel(string_or_int_prop=1))
+
+    def test_type_hints(self, MyModel, Unset):
+        assert_model_property_type_hint(MyModel, "string_or_int_prop", Union[str, int, Unset])
+
+
+@with_generated_client_fixture(
+"""
+# Test cases where there's a union of types *and* an explicit list of multiple "type:"s -
+# there was a bug where this could cause enum/model classes to be generated incorrectly
+
+components:
+  schemas:
+    MyStringEnum:
+      type: string
+      enum: ["a", "b"]
+    MyIntEnum:
+      type: integer
+      enum: [1, 2]
+    MyEnumIncludingNull:
+      type: ["string", "null"]
+      enum: ["a", "b", null]
+    MyObject:
+      type: object
+      properties:
+        name:
+          type: string
+    MyModel:
+      properties:
+        enumsWithListOfTypesProp:
+          type: ["string", "integer"]
+          oneOf:
+            - {"$ref": "#/components/schemas/MyStringEnum"}
+            - {"$ref": "#/components/schemas/MyIntEnum"}
+        enumIncludingNullProp: {"$ref": "#/components/schemas/MyEnumIncludingNull"}
+        nullableObjectWithListOfTypesProp:
+          type: ["string", "object"]
+          oneOf:
+            - {"$ref": "#/components/schemas/MyObject"}
+            - type: "null"
+""")
+@with_generated_code_imports(
+    ".models.MyStringEnum",
+    ".models.MyIntEnum",
+    ".models.MyEnumIncludingNull",
+    ".models.MyObject",
+    ".models.MyModel",
+    ".types.Unset",
+)
+class TestUnionsWithListOfSimpleTypes:
+    def test_union_of_enums(self, MyModel, MyStringEnum, MyIntEnum):
+        assert_model_decode_encode(
+            MyModel,
+            {"enumsWithListOfTypesProp": "b"},
+            MyModel(enums_with_list_of_types_prop=MyStringEnum.B),
+        )
+        assert_model_decode_encode(
+            MyModel,
+            {"enumsWithListOfTypesProp": 2},
+            MyModel(enums_with_list_of_types_prop=MyIntEnum.VALUE_2),
+        )
+
+    def test_union_of_enum_with_null(self, MyModel, MyEnumIncludingNull):
+        assert_model_decode_encode(
+            MyModel,
+            {"enumIncludingNullProp": "b"},
+            MyModel(enum_including_null_prop=MyEnumIncludingNull.B),
+        )
+        assert_model_decode_encode(
+            MyModel,
+            {"enumIncludingNullProp": None},
+            MyModel(enum_including_null_prop=None),
+        )
+
+    def test_nullable_object_with_list_of_types(self, MyModel, MyObject):
+        assert_model_decode_encode(
+            MyModel,
+            {"nullableObjectWithListOfTypesProp": {"name": "a"}},
+            MyModel(nullable_object_with_list_of_types_prop=MyObject(name="a")),
+        )
+        assert_model_decode_encode(
+            MyModel,
+            {"nullableObjectWithListOfTypesProp": None},
+            MyModel(nullable_object_with_list_of_types_prop=None),
+        )
diff --git a/end_to_end_tests/generated_client.py b/end_to_end_tests/generated_client.py
@@ -52,8 +52,9 @@ def import_symbol(self, module_path: str, name: str) -> Any:
         except AttributeError:
             existing = ", ".join(name for name in dir(module) if not name.startswith("_"))
             assert False, (
-                f"Couldn't find import \"{name}\" in \"{self.base_module}{module_path}\"."
-                f" Available imports in that module are: {existing}"
+                f"Couldn't find import \"{name}\" in \"{self.base_module}{module_path}\".\n"
+                f"Available imports in that module are: {existing}\n"
+                f"Output from generator was: {self.generator_result.stdout}"
             )
 
 def _run_command(
diff --git a/openapi_python_client/parser/properties/union.py b/openapi_python_client/parser/properties/union.py
@@ -77,12 +77,26 @@ def build(
         """
         from . import property_from_data
 
-        sub_properties: list[PropertyProtocol] = []
-
         type_list_data = []
         if isinstance(data.type, list) and not (data.anyOf or data.oneOf):
+            # The schema specifies "type:" with a list of allowable types. If there is *not* also an "anyOf"
+            # or "oneOf", then we should treat that as a shorthand for a oneOf where each variant is just
+            # a single "type:". For example, this--
+            #   type:
+            #     - string
+            #     - int
+            # --becomes this:
+            #   oneOf:
+            #     - type: string
+            #     - type: int
+            # (We don't copy any other attributes from the top-level schema into the variants, like "default:",
+            # because they don't necessarily apply to every one of those types. The default will be handled
+            # at the UnionProperty level, not in the variants. The same goes for description, example, etc.)
+            #
+            # However, if there *is* also an "anyOf" or "oneOf" list, then the information from "type:" is
+            # redundant since every allowable variant type is already fully described in the list.
             for _type in data.type:
-                type_list_data.append(data.model_copy(update={"type": _type, "default": None}))
+                type_list_data.append(oai.Schema.model_construct(type=_type))
 
         def process_items(
             preserve_name_for_item: oai.Schema | oai.Reference | None = None,
