Unit test coverage for new property/response code

Author: dbanty

openapi_python_client/parser/properties/model_property.py

@@ -17,8 +17,7 @@ class ModelProperty(Property):
     description: str
     relative_imports: Set[str]
 
-    template: ClassVar[str] = "ref_property.pyi"
-    # TODO: change to model_property.pyi
+    template: ClassVar[str] = "model_property.pyi"
 
     def get_type_string(self, no_optional: bool = False) -> str:
         """ Get a string representation of type that should be used when declaring this property """

openapi_python_client/parser/responses.py

@@ -1,3 +1,5 @@
+__all__ = ["Response", "response_from_data"]
+
 from typing import Tuple, Union
 
 import attr
@@ -63,7 +65,7 @@ def response_from_data(
         required=True,
         data=schema_data,
         schemas=schemas,
-        parent_name=f"{parent_name}",
+        parent_name=parent_name,
     )
 
     if isinstance(prop, PropertyError):

openapi_python_client/templates/property_templates/ref_property.pyi renamed to openapi_python_client/templates/property_templates/model_property.pyi

@@ -0,0 +1,41 @@
+import pytest
+
+from openapi_python_client.parser.errors import ValidationError
+from openapi_python_client.parser.properties.converter import convert, convert_chain
+
+
+def test_convert_none():
+    assert convert("blah", None) is None
+
+
+def test_convert_bad_type():
+    with pytest.raises(ValidationError):
+        assert convert("blah", "blah")
+
+
+def test_convert_exception():
+    with pytest.raises(ValidationError):
+        assert convert("datetime.datetime", "blah")
+
+
+def test_convert_str():
+    # This looks ugly, but it outputs in jinja as '\\"str\\"'
+    # The extra escape of " is not necessary but the code is overly cautious
+    assert convert("str", '"str"') == "'\\\\\"str\\\\\"'"
+
+
+def test_convert_datetime():
+    assert convert("datetime.datetime", "2021-01-20") == "isoparse('2021-01-20')"
+
+
+def test_convert_date():
+    assert convert("datetime.date", "2021-01-20") == "isoparse('2021-01-20').date()"
+
+
+def test_convert_chain_no_valid():
+    with pytest.raises(ValidationError):
+        convert_chain(("int",), "a")
+
+
+def test_convert_chain():
+    assert convert_chain(("int", "bool"), "a")

tests/test_parser/test_properties/test_converter.py

@@ -2,7 +2,15 @@
 
 import openapi_python_client.schema as oai
 from openapi_python_client.parser.errors import PropertyError, ValidationError
-from openapi_python_client.parser.properties import BooleanProperty, FloatProperty, IntProperty
+from openapi_python_client.parser.properties import (
+    BooleanProperty,
+    DateTimeProperty,
+    FloatProperty,
+    IntProperty,
+    ModelProperty,
+    StringProperty,
+)
+from openapi_python_client.parser.reference import Reference
 
 MODULE_NAME = "openapi_python_client.parser.properties"
 
@@ -689,6 +697,25 @@ def test_property_from_data_array(self, mocker):
             data=data, name=name, required=required, schemas=schemas, parent_name="parent"
         )
 
+    def test_property_from_data_object(self, mocker):
+        from openapi_python_client.parser.properties import Schemas, property_from_data
+
+        name = mocker.MagicMock()
+        required = mocker.MagicMock()
+        data = oai.Schema(
+            type="object",
+        )
+        build_model_property = mocker.patch(f"{MODULE_NAME}.build_model_property")
+        mocker.patch("openapi_python_client.utils.remove_string_escapes", return_value=name)
+        schemas = Schemas()
+
+        response = property_from_data(name=name, required=required, data=data, schemas=schemas, parent_name="parent")
+
+        assert response == build_model_property.return_value
+        build_model_property.assert_called_once_with(
+            data=data, name=name, required=required, schemas=schemas, parent_name="parent"
+        )
+
     def test_property_from_data_union(self, mocker):
         from openapi_python_client.parser.properties import Schemas, property_from_data
 
@@ -1010,3 +1037,108 @@ def test_build_enums(mocker):
 
     build_enum_property.assert_called()
     build_model_property.assert_not_called()
+
+
+def test_build_model_property():
+    from openapi_python_client.parser.properties import Schemas, build_model_property
+
+    data = oai.Schema.construct(
+        required=["req"],
+        title="MyModel",
+        properties={
+            "req": oai.Schema.construct(type="string"),
+            "opt": oai.Schema(type="string", format="date-time"),
+        },
+        description="A class called MyModel",
+        nullable=False,
+    )
+    schemas = Schemas(models={"OtherModel": None})
+
+    model, new_schemas = build_model_property(
+        data=data,
+        name="prop",
+        schemas=schemas,
+        required=True,
+        parent_name="parent",
+    )
+
+    assert new_schemas != schemas
+    assert new_schemas.models == {
+        "OtherModel": None,
+        "ParentMyModel": model,
+    }
+    assert model == ModelProperty(
+        name="prop",
+        required=True,
+        nullable=False,
+        default=None,
+        reference=Reference(class_name="ParentMyModel", module_name="parent_my_model"),
+        required_properties=[StringProperty(name="req", required=True, nullable=False, default=None)],
+        optional_properties=[DateTimeProperty(name="opt", required=True, nullable=False, default=None)],
+        description=data.description,
+        relative_imports={"from dateutil.parser import isoparse", "from typing import cast", "import datetime"},
+    )
+
+
+def test_build_model_property_bad_prop():
+    from openapi_python_client.parser.properties import Schemas, build_model_property
+
+    data = oai.Schema(
+        properties={
+            "bad": oai.Schema(type="not_real"),
+        },
+    )
+    schemas = Schemas(models={"OtherModel": None})
+
+    err, new_schemas = build_model_property(
+        data=data,
+        name="prop",
+        schemas=schemas,
+        required=True,
+        parent_name=None,
+    )
+
+    assert new_schemas == schemas
+    assert err == PropertyError(detail="unknown type not_real", data=oai.Schema(type="not_real"))
+
+
+def test_build_enum_property_conflict(mocker):
+    from openapi_python_client.parser.properties import Schemas, build_enum_property
+
+    data = oai.Schema()
+    schemas = Schemas(enums={"Existing": mocker.MagicMock()})
+
+    err, schemas = build_enum_property(
+        data=data, name="Existing", required=True, schemas=schemas, enum=[], parent_name=None
+    )
+
+    assert schemas == schemas
+    assert err == PropertyError(detail="Found conflicting enums named Existing with incompatible values.", data=data)
+
+
+def test_build_enum_property_no_values():
+    from openapi_python_client.parser.properties import Schemas, build_enum_property
+
+    data = oai.Schema()
+    schemas = Schemas()
+
+    err, schemas = build_enum_property(
+        data=data, name="Existing", required=True, schemas=schemas, enum=[], parent_name=None
+    )
+
+    assert schemas == schemas
+    assert err == PropertyError(detail="No values provided for Enum", data=data)
+
+
+def test_build_enum_property_bad_default():
+    from openapi_python_client.parser.properties import Schemas, build_enum_property
+
+    data = oai.Schema(default="B")
+    schemas = Schemas()
+
+    err, schemas = build_enum_property(
+        data=data, name="Existing", required=True, schemas=schemas, enum=["A"], parent_name=None
+    )
+
+    assert schemas == schemas
+    assert err == PropertyError(detail="B is an invalid default for enum Existing", data=data)

tests/test_parser/test_properties/test_init.py

@@ -0,0 +1,57 @@
+import pytest
+
+
+@pytest.mark.parametrize(
+    "no_optional,nullable,required,expected",
+    [
+        (False, False, False, "Union[MyClass, Unset]"),
+        (False, False, True, "MyClass"),
+        (False, True, False, "Union[Optional[MyClass], Unset]"),
+        (False, True, True, "Optional[MyClass]"),
+        (True, False, False, "MyClass"),
+        (True, False, True, "MyClass"),
+        (True, True, False, "MyClass"),
+        (True, True, True, "MyClass"),
+    ],
+)
+def test_get_type_string(no_optional, nullable, required, expected):
+    from openapi_python_client.parser.properties import ModelProperty, Reference
+
+    prop = ModelProperty(
+        name="prop",
+        required=required,
+        nullable=nullable,
+        default=None,
+        reference=Reference(class_name="MyClass", module_name="my_module"),
+        description="",
+        optional_properties=[],
+        required_properties=[],
+        relative_imports=set(),
+    )
+
+    assert prop.get_type_string(no_optional=no_optional) == expected
+
+
+def test_get_imports():
+    from openapi_python_client.parser.properties import ModelProperty, Reference
+
+    prop = ModelProperty(
+        name="prop",
+        required=False,
+        nullable=True,
+        default=None,
+        reference=Reference(class_name="MyClass", module_name="my_module"),
+        description="",
+        optional_properties=[],
+        required_properties=[],
+        relative_imports=set(),
+    )
+
+    assert prop.get_imports(prefix="..") == {
+        "from typing import Optional",
+        "from typing import Union",
+        "from ..types import UNSET, Unset",
+        "from ..models.my_module import MyClass",
+        "from typing import Dict",
+        "from typing import cast",
+    }

tests/test_parser/test_properties/test_model_property.py

@@ -1,5 +1,80 @@
 import openapi_python_client.schema as oai
+from openapi_python_client.parser.errors import ParseError, PropertyError
+from openapi_python_client.parser.properties import NoneProperty, Schemas, StringProperty
 
 MODULE_NAME = "openapi_python_client.parser.responses"
 
-# TODO: Test response_from_data
+
+def test_response_from_data_no_content():
+    from openapi_python_client.parser.responses import Response, response_from_data
+
+    response, schemas = response_from_data(
+        status_code=200, data=oai.Response.construct(description=""), schemas=Schemas(), parent_name="parent"
+    )
+
+    assert response == Response(
+        status_code=200,
+        prop=NoneProperty(name="response_200", default=None, nullable=False, required=True),
+        source="None",
+    )
+
+
+def test_response_from_data_unsupported_content_type():
+    from openapi_python_client.parser.responses import response_from_data
+
+    data = oai.Response.construct(description="", content={"blah": None})
+    response, schemas = response_from_data(status_code=200, data=data, schemas=Schemas(), parent_name="parent")
+
+    assert response == ParseError(data=data, detail="Unsupported content_type {'blah': None}")
+
+
+def test_response_from_data_no_content_schema():
+    from openapi_python_client.parser.responses import Response, response_from_data
+
+    data = oai.Response.construct(description="", content={"application/json": oai.MediaType.construct()})
+    response, schemas = response_from_data(status_code=200, data=data, schemas=Schemas(), parent_name="parent")
+
+    assert response == Response(
+        status_code=200,
+        prop=NoneProperty(name="response_200", default=None, nullable=False, required=True),
+        source="None",
+    )
+
+
+def test_response_from_data_property_error(mocker):
+    from openapi_python_client.parser import responses
+
+    property_from_data = mocker.patch.object(responses, "property_from_data", return_value=(PropertyError(), Schemas()))
+    data = oai.Response.construct(
+        description="", content={"application/json": oai.MediaType.construct(media_type_schema="something")}
+    )
+    response, schemas = responses.response_from_data(
+        status_code=400, data=data, schemas=Schemas(), parent_name="parent"
+    )
+
+    assert response == PropertyError()
+    property_from_data.assert_called_once_with(
+        name="response_400", required=True, data="something", schemas=Schemas(), parent_name="parent"
+    )
+
+
+def test_response_from_data_property(mocker):
+    from openapi_python_client.parser import responses
+
+    prop = StringProperty(name="prop", required=True, nullable=False, default=None)
+    property_from_data = mocker.patch.object(responses, "property_from_data", return_value=(prop, Schemas()))
+    data = oai.Response.construct(
+        description="", content={"application/json": oai.MediaType.construct(media_type_schema="something")}
+    )
+    response, schemas = responses.response_from_data(
+        status_code=400, data=data, schemas=Schemas(), parent_name="parent"
+    )
+
+    assert response == responses.Response(
+        status_code=400,
+        prop=prop,
+        source="response.json()",
+    )
+    property_from_data.assert_called_once_with(
+        name="response_400", required=True, data="something", schemas=Schemas(), parent_name="parent"
+    )