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,22 @@
         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}
 """)
 @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 +59,31 @@ 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",
         )
-        # 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 +108,46 @@ 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": "c"}
 """
         )
 
-    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 c 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,24 +35,44 @@
           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))
+        assert_model_decode_encode(
+            MyModel,
+            {"inlineEnumProp": "a"},
+            MyModel(inline_enum_prop=MyModelInlineEnumProp.A),
+        )
 
-    def test_enum_prop_type(self, MyModel, MyEnum, MyIntEnum):
+    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)
-        assert isinstance(MyModel.from_dict({"intEnumProp": 2}).int_enum_prop, MyIntEnum)
 
-    def test_nullable_enum_prop(self, MyModel, 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"},
@@ -57,6 +83,17 @@ def test_nullable_enum_prop(self, MyModel, MyEnum):
             {"nullableEnumProp": None},
             MyModel(nullable_enum_prop=None),
         )
+        assert_model_decode_encode(
+            MyModel,
+            {"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):
@@ -202,3 +239,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)

Diff for: end_to_end_tests/generated_code_live_tests/test_property_encoding.py

@@ -133,6 +133,7 @@ def test_decode_error_not_object(self, bad_data, MyModel):
         dateProp: {"type": "string", "format": "date"}
         dateTimeProp: {"type": "string", "format": "date-time"}
         uuidProp: {"type": "string", "format": "uuid"}
+        unknownFormatProp: {"type": "string", "format": "weird"}
 """)
 @with_generated_code_imports(".models.MyModel")
 class TestSpecialStringFormats:
@@ -150,3 +151,7 @@ def test_uuid(self, MyModel):
         uuid_value = uuid.uuid1()
         json_data = {"uuidProp": str(uuid_value)}
         assert_model_decode_encode(MyModel, json_data, MyModel(uuid_prop=uuid_value))
+
+    def test_unknown_format(self, MyModel):
+        json_data = {"unknownFormatProp": "whatever"}
+        assert_model_decode_encode(MyModel, json_data, MyModel(unknown_format_prop="whatever"))