misc improvements + remove redundant unit tests

Author: eli-bl

Diff for: end_to_end_tests/end_to_end_test_helpers.py

@@ -156,13 +156,13 @@ def inline_spec_should_fail(
 ) -> Result:
     """Asserts that the generator could not process the spec.
     
-    Returns the full output.
+    Returns the command result, which could include stdout data or an exception.
     """
     with generate_client_from_inline_spec(
         openapi_spec, extra_args, filename_suffix, config, add_missing_sections, raise_on_error=False
     ) as generated_client:
         assert generated_client.generator_result.exit_code != 0
-        return generated_client.generator_result.stdout
+        return generated_client.generator_result
 
 
 def inline_spec_should_cause_warnings(
@@ -198,6 +198,7 @@ def with_generated_client_fixture(
     def _decorator(cls):
         def generated_client(self):
             with generate_client_from_inline_spec(openapi_spec, extra_args=extra_args, config=config) as g:
+                print(g.generator_result.stdout)  # so we'll see the output if a test failed
                 yield g
 
         setattr(cls, name, pytest.fixture(scope="class")(generated_client))

Diff for: end_to_end_tests/generated_code_live_tests/test_defaults.py

@@ -22,7 +22,9 @@
         stringProp: {"type": "string", "default": "a"}
         numberProp: {"type": "number", "default": 1.5}
         intProp: {"type": "integer", "default": 2}
-        noneProp: {"type": "null", "default": null}
+        dateProp: {"type": "string", "format": "date", "default": "2024-01-02"}
+        dateTimeProp: {"type": "string", "format": "date-time", "default": "2024-01-02T03:04:05Z"}
+        uuidProp: {"type": "string", "format": "uuid", "default": "07EF8B4D-AA09-4FFA-898D-C710796AFF41"}
         anyPropWithString: {"default": "b"}
         anyPropWithInt: {"default": 3}
         booleanWithStringTrue1: {"type": "boolean", "default": "True"}
@@ -32,17 +34,23 @@
         intWithStringValue: {"type": "integer", "default": "4"}
         numberWithIntValue: {"type": "number", "default": 5}
         numberWithStringValue: {"type": "number", "default": "5.5"}
-        noneWithStringValue: {"type": "null", "default": "None"}
+        stringWithNumberValue: {"type": "string", "default": 6}
+        stringConst: {"type": "string", "const": "always", "default": "always"}
 """)
 @with_generated_code_imports(".models.MyModel")
-class TestDefaultValues:
-    def test_defaults_in_initializer(self, MyModel, generated_client):
+class TestSimpleDefaults:
+    # Note, the null/None type is not covered here due to a known bug:
+    # https://github.com/openapi-generators/openapi-python-client/issues/1162
+    def test_defaults_in_initializer(self, MyModel):
         instance = MyModel()
         assert instance == MyModel(
             boolean_prop=True,
             string_prop="a",
             number_prop=1.5,
             int_prop=2,
+            date_prop=datetime.date(2024, 1, 2),
+            date_time_prop=datetime.datetime(2024, 1, 2, 3, 4, 5, tzinfo=datetime.timezone.utc),
+            uuid_prop=uuid.UUID("07EF8B4D-AA09-4FFA-898D-C710796AFF41"),
             any_prop_with_string="b",
             any_prop_with_int=3,
             boolean_with_string_true_1=True,
@@ -52,9 +60,32 @@ def test_defaults_in_initializer(self, MyModel, generated_client):
             int_with_string_value=4,
             number_with_int_value=5,
             number_with_string_value=5.5,
+            string_with_number_value="6",
+            string_const="always",
         )
-        # Note, currently the default for a None property does not work as expected--
-        # the initializer will default it to UNSET rather than None.
+
+
+
+@with_generated_client_fixture(
+"""
+components:
+  schemas:
+    MyEnum:
+      type: string
+      enum: ["a", "b"]
+    MyModel:
+      type: object
+      properties:
+        enumProp:
+          allOf:
+            - $ref: "#/components/schemas/MyEnum"
+          default: "a"
+
+""")
+@with_generated_code_imports(".models.MyEnum", ".models.MyModel")
+class TestEnumDefaults:
+    def test_enum_default(self, MyEnum, MyModel):
+        assert MyModel().enum_prop == MyEnum.A
 
 
 class TestInvalidDefaultValues:
@@ -79,20 +110,48 @@ def warnings(self):
     WithBadFloatAsOther:
       properties:
         badInt: {"type": "number", "default": true}
+    WithBadDateAsString:
+      properties:
+        badDate: {"type": "string", "format": "date", "default": "xxx"}
+    WithBadDateAsOther:
+      properties:
+        badDate: {"type": "string", "format": "date", "default": 3}
+    WithBadDateTimeAsString:
+      properties:
+        badDate: {"type": "string", "format": "date-time", "default": "xxx"}
+    WithBadDateTimeAsOther:
+      properties:
+        badDate: {"type": "string", "format": "date-time", "default": 3}
+    WithBadUuidAsString:
+      properties:
+        badUuid: {"type": "string", "format": "uuid", "default": "xxx"}
+    WithBadUuidAsOther:
+      properties:
+        badUuid: {"type": "string", "format": "uuid", "default": 3}
+    WithBadEnum:
+      properties:
+        badEnum: {"type": "string", "enum": ["a", "b"], "default": "x"}
 """
         )
+    # Note, the null/None type, and binary strings (files), are not covered here due to a known bug:
+    # https://github.com/openapi-generators/openapi-python-client/issues/1162
 
-    def test_bad_boolean(self, warnings):
-        assert_bad_schema_warning(warnings, "WithBadBoolean", "Invalid boolean value")
-
-    def test_bad_int_as_string(self, warnings):
-        assert_bad_schema_warning(warnings, "WithBadIntAsString", "Invalid int value")
-
-    def test_bad_int_as_other(self, warnings):
-        assert_bad_schema_warning(warnings, "WithBadIntAsOther", "Invalid int value")
-
-    def test_bad_float_as_string(self, warnings):
-        assert_bad_schema_warning(warnings, "WithBadFloatAsString", "Invalid float value")
-
-    def test_bad_float_as_other(self, warnings):
-        assert_bad_schema_warning(warnings, "WithBadFloatAsOther", "Cannot convert True to a float")
+    @pytest.mark.parametrize(
+        ("model_name", "message"),
+        [
+            ("WithBadBoolean", "Invalid boolean value"),
+            ("WithBadIntAsString", "Invalid int value"),
+            ("WithBadIntAsOther", "Invalid int value"),
+            ("WithBadFloatAsString", "Invalid float value"),
+            ("WithBadFloatAsOther", "Cannot convert True to a float"),
+            ("WithBadDateAsString", "Invalid date"),
+            ("WithBadDateAsOther", "Cannot convert 3 to a date"),
+            ("WithBadDateTimeAsString", "Invalid datetime"),
+            ("WithBadDateTimeAsOther", "Cannot convert 3 to a datetime"),
+            ("WithBadUuidAsString", "Invalid UUID value"),
+            ("WithBadUuidAsOther", "Invalid UUID value"),
+            ("WithBadEnum", "Value x is not valid for enum"),
+        ]
+    )
+    def test_bad_default_warning(self, model_name, message, warnings):
+        assert_bad_schema_warning(warnings, model_name, message)

Diff for: end_to_end_tests/generated_code_live_tests/test_enum_and_const.py

@@ -5,6 +5,7 @@
     assert_bad_schema_warning,
     assert_model_decode_encode,
     inline_spec_should_cause_warnings,
+    inline_spec_should_fail,
     with_generated_code_import,
     with_generated_client_fixture,
     with_generated_code_imports,
@@ -17,10 +18,15 @@
   schemas:
     MyEnum:
       type: string
-      enum: ["a", "B"]
+      enum: ["a", "B", "~weirdstring"]
     MyIntEnum:
       type: integer
-      enum: [2, 3]
+      enum: [2, 3, -4]
+    MyEnumIncludingNull:
+      type: ["string", "null"]
+      enum: ["a", "b", null]
+    MyNullOnlyEnum:
+      enum: [null]
     MyModel:
       properties:
         enumProp: {"$ref": "#/components/schemas/MyEnum"}
@@ -29,34 +35,53 @@
           oneOf:
             - {"$ref": "#/components/schemas/MyEnum"}
             - type: "null"
+        enumIncludingNullProp: {"$ref": "#/components/schemas/MyEnumIncludingNull"}
+        nullOnlyEnumProp: {"$ref": "#/components/schemas/MyNullOnlyEnum"}
+        inlineEnumProp:
+          type: string
+          enum: ["a", "b"]
 """)
-@with_generated_code_imports(".models.MyEnum", ".models.MyIntEnum", ".models.MyModel")
+@with_generated_code_imports(
+    ".models.MyEnum",
+    ".models.MyIntEnum",
+    ".models.MyEnumIncludingNullType1", # see comment in test_nullable_enum_prop
+    ".models.MyModel",
+    ".models.MyModelInlineEnumProp",
+)
 class TestEnumClasses:
     def test_enum_classes(self, MyEnum, MyIntEnum):
         assert MyEnum.A == MyEnum("a")
         assert MyEnum.B == MyEnum("B")
+        assert MyEnum.VALUE_2 == MyEnum("~weirdstring")
         assert MyIntEnum.VALUE_2 == MyIntEnum(2)
         assert MyIntEnum.VALUE_3 == MyIntEnum(3)
+        assert MyIntEnum.VALUE_NEGATIVE_4 == MyIntEnum(-4)
 
-    def test_enum_prop(self, MyModel, MyEnum, MyIntEnum):
+    def test_enum_prop(self, MyModel, MyEnum, MyIntEnum, MyModelInlineEnumProp):
         assert_model_decode_encode(MyModel, {"enumProp": "B"}, MyModel(enum_prop=MyEnum.B))
         assert_model_decode_encode(MyModel, {"intEnumProp": 2}, MyModel(int_enum_prop=MyIntEnum.VALUE_2))
-
-    def test_enum_prop_type(self, MyModel, MyEnum, MyIntEnum):
-        assert isinstance(MyModel.from_dict({"enumProp": "B"}).enum_prop, MyEnum)
-        assert isinstance(MyModel.from_dict({"intEnumProp": 2}).int_enum_prop, MyIntEnum)
-
-    def test_nullable_enum_prop(self, MyModel, MyEnum):
         assert_model_decode_encode(
             MyModel,
-            {"nullableEnumProp": "B"},
-            MyModel(nullable_enum_prop=MyEnum.B),
+            {"inlineEnumProp": "a"},
+            MyModel(inline_enum_prop=MyModelInlineEnumProp.A),
         )
+
+    def test_enum_prop_type(self, MyModel, MyEnum):
+        # Just verifying that it's not using a literal vaue
+        assert isinstance(MyModel.from_dict({"enumProp": "B"}).enum_prop, MyEnum)
+
+    def test_nullable_enum_prop(self, MyModel, MyEnum, MyEnumIncludingNullType1):
+        # Note, MyEnumIncludingNullType1 should be named just MyEnumIncludingNull -
+        # known bug: https://github.com/openapi-generators/openapi-python-client/issues/1120
+        assert_model_decode_encode(MyModel, {"nullableEnumProp": "B"}, MyModel(nullable_enum_prop=MyEnum.B))
+        assert_model_decode_encode(MyModel, {"nullableEnumProp": None}, MyModel(nullable_enum_prop=None))
         assert_model_decode_encode(
             MyModel,
-            {"nullableEnumProp": None},
-            MyModel(nullable_enum_prop=None),
+            {"enumIncludingNullProp": "a"},
+            MyModel(enum_including_null_prop=MyEnumIncludingNullType1.A),
         )
+        assert_model_decode_encode( MyModel, {"enumIncludingNullProp": None}, MyModel(enum_including_null_prop=None))
+        assert_model_decode_encode(MyModel, {"nullOnlyEnumProp": None}, MyModel(null_only_enum_prop=None))
 
     def test_invalid_values(self, MyModel):
         with pytest.raises(ValueError):
@@ -71,63 +96,6 @@ def test_invalid_values(self, MyModel):
             MyModel.from_dict({"intEnumProp": "a"})
 
 
-@with_generated_client_fixture(
-"""
-components:
-  schemas:
-    MyEnum:
-      type: string
-      enum: ["a", "A"]
-    MyIntEnum:
-      type: integer
-      enum: [2, 3]
-    MyModel:
-      properties:
-        enumProp: {"$ref": "#/components/schemas/MyEnum"}
-        intEnumProp: {"$ref": "#/components/schemas/MyIntEnum"}
-        nullableEnumProp:
-          oneOf:
-            - {"$ref": "#/components/schemas/MyEnum"}
-            - type: "null"
-""",
-    config="""
-literal_enums: true
-""",
-)
-@with_generated_code_import(".models.MyModel")
-class TestLiteralEnums:
-    def test_enum_prop(self, MyModel):
-        assert_model_decode_encode(MyModel, {"enumProp": "a"}, MyModel(enum_prop="a"))
-        assert_model_decode_encode(MyModel, {"enumProp": "A"}, MyModel(enum_prop="A"))
-        assert_model_decode_encode(MyModel, {"intEnumProp": 2}, MyModel(int_enum_prop=2))
-
-    def test_enum_prop_type(self, MyModel):
-        assert MyModel.from_dict({"enumProp": "a"}).enum_prop.__class__ is str
-        assert MyModel.from_dict({"intEnumProp": 2}).int_enum_prop.__class__ is int
-
-    def test_nullable_enum_prop(self, MyModel):
-        assert_model_decode_encode(
-            MyModel,
-            {"nullableEnumProp": "a"},
-            MyModel(nullable_enum_prop="a"),
-        )
-        assert_model_decode_encode(
-            MyModel,
-            {"nullableEnumProp": None},
-            MyModel(nullable_enum_prop=None),
-        )
-
-    def test_invalid_values(self, MyModel):
-        with pytest.raises(TypeError):
-            MyModel.from_dict({"enumProp": "c"})
-        with pytest.raises(TypeError):
-            MyModel.from_dict({"enumProp": 2})
-        with pytest.raises(TypeError):
-            MyModel.from_dict({"intEnumProp": 0})
-        with pytest.raises(TypeError):
-            MyModel.from_dict({"intEnumProp": "a"})
-
-
 @with_generated_client_fixture(
 """
 components:
@@ -202,3 +170,15 @@ def test_enum_unsupported_type(self, warnings):
 
     def test_const_default_not_matching(self, warnings):
         assert_bad_schema_warning(warnings, "DefaultNotMatchingConst", "Invalid value for const")
+
+    def test_enum_duplicate_values(self):
+        # This one currently causes a full generator failure rather than a warning
+        result = inline_spec_should_fail(
+"""
+components:
+  schemas:
+    WithDuplicateValues:
+      enum: ["x", "x"]
+"""
+        )
+        assert "Duplicate key X in enum" in str(result.exception)