def test_get_type_string(self):
from openapi_python_client.parser.properties import StringProperty
p = StringProperty(name="test", required=True, default=None)
assert p.get_type_string() == "str"
p.required = False
assert p.get_type_string() == "Optional[str]"
def test__validate_default(self):
from openapi_python_client.parser.properties import StringProperty
p = StringProperty(name="a name",
required=True,
default="the default value")
assert p.default == '"the default value"'
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")
def string_property(**kwargs) -> StringProperty:
kwargs = {
"name": "",
"required": True,
"nullable": True,
"default": None,
**kwargs,
}
return StringProperty(**kwargs)
def test__string_based_property_unsupported_format(self, mocker):
from openapi_python_client.parser.properties import StringProperty, _string_based_property
name = "unknown"
required = True
data = oai.Schema.construct(type="string", schema_format="blah", nullable=True)
p = _string_based_property(name=name, required=required, data=data)
assert p == StringProperty(name=name, required=required, nullable=True, default=None)
def test__string_based_property_no_format(self, mocker):
name = mocker.MagicMock()
required = mocker.MagicMock()
data = oai.Schema.construct(type="string")
StringProperty = mocker.patch(f"{MODULE_NAME}.StringProperty")
from openapi_python_client.parser.properties import _string_based_property
p = _string_based_property(name=name, required=required, data=data)
StringProperty.assert_called_once_with(name=name,
required=required,
pattern=None,
default=None)
assert p == StringProperty.return_value
# Test optional values
StringProperty.reset_mock()
data.default = mocker.MagicMock()
data.pattern = mocker.MagicMock()
_string_based_property(
name=name,
required=required,
data=data,
)
StringProperty.assert_called_once_with(name=name,
required=required,
pattern=data.pattern,
default=data.default)
def test__string_based_property_no_format(self):
from openapi_python_client.parser.properties import StringProperty
name = "some_prop"
required = True
data = oai.Schema.construct(type="string", nullable=True, default='"hello world"')
from openapi_python_client.parser.properties import _string_based_property
p = _string_based_property(name=name, required=required, data=data)
assert p == StringProperty(name=name, required=required, nullable=True, default="'\\\\\"hello world\\\\\"'")
data.pattern = "abcdef"
data.nullable = False
p = _string_based_property(
name=name,
required=required,
data=data,
)
assert p == StringProperty(
name=name, required=required, nullable=False, default="'\\\\\"hello world\\\\\"'", pattern="abcdef"
)
def test_build_model_property(additional_properties_schema, expected_additional_properties):
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,
additionalProperties=additional_properties_schema,
)
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=False, nullable=False, default=None)],
description=data.description,
relative_imports={
"from dateutil.parser import isoparse",
"from typing import cast",
"import datetime",
"from ..types import UNSET, Unset",
"from typing import Union",
},
additional_properties=expected_additional_properties,
)
def test_conflicting_properties_different_types(self, model_property_factory):
from openapi_python_client.parser.properties import Schemas
from openapi_python_client.parser.properties.model_property import _process_properties
data = oai.Schema.construct(
allOf=[oai.Reference.construct(ref="#/First"), oai.Reference.construct(ref="#/Second")]
)
schemas = Schemas(
classes_by_reference={
"/First": model_property_factory(
optional_properties=[StringProperty(name="prop", required=True, nullable=True, default=None)]
),
"/Second": model_property_factory(
optional_properties=[DateTimeProperty(name="prop", required=True, nullable=True, default=None)]
),
}
)
result = _process_properties(data=data, schemas=schemas, class_name="", config=Config())
assert isinstance(result, PropertyError)
class TestBuildModelProperty:
@pytest.mark.parametrize(
"additional_properties_schema, expected_additional_properties",
[
(True, True),
(oai.Schema.construct(), True),
(None, True),
(False, False),
(
oai.Schema.construct(type="string"),
StringProperty(
name="AdditionalProperty",
required=True,
nullable=False,
default=None,
python_name="additional_property",
),
),
],
)
def test_additional_schemas(self, additional_properties_schema,
expected_additional_properties):
from openapi_python_client.parser.properties import Schemas, build_model_property
data = oai.Schema.construct(
additionalProperties=additional_properties_schema, )
model, _ = build_model_property(data=data,
name="prop",
schemas=Schemas(),
required=True,
parent_name="parent",
config=MagicMock())
assert model.additional_properties == expected_additional_properties
def test_happy_path(self, model_property_factory, string_property_factory,
date_time_property_factory):
from openapi_python_client.parser.properties import Class, Schemas, build_model_property
name = "prop"
nullable = False
required = True
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=nullable,
)
schemas = Schemas(classes_by_reference={"OtherModel": None},
classes_by_name={"OtherModel": None})
model, new_schemas = build_model_property(data=data,
name=name,
schemas=schemas,
required=required,
parent_name="parent",
config=Config())
assert new_schemas != schemas
assert new_schemas.classes_by_name == {
"OtherModel": None,
"ParentMyModel": model,
}
assert new_schemas.classes_by_reference == {
"OtherModel": None,
}
assert model == model_property_factory(
name=name,
required=required,
nullable=nullable,
class_info=Class(name="ParentMyModel",
module_name="parent_my_model"),
required_properties=[
string_property_factory(name="req", required=True)
],
optional_properties=[
date_time_property_factory(name="opt", required=False)
],
description=data.description,
relative_imports={
"from dateutil.parser import isoparse",
"from typing import cast",
"import datetime",
"from ..types import UNSET, Unset",
"from typing import Union",
},
additional_properties=True,
)
def test_model_name_conflict(self):
from openapi_python_client.parser.properties import Schemas, build_model_property
data = oai.Schema.construct()
schemas = Schemas(classes_by_name={"OtherModel": None})
err, new_schemas = build_model_property(data=data,
name="OtherModel",
schemas=schemas,
required=True,
parent_name=None,
config=Config())
assert new_schemas == schemas
assert err == PropertyError(
detail=
'Attempted to generate duplicate models with name "OtherModel"',
data=data)
def test_bad_props_return_error(self):
from openapi_python_client.parser.properties import Schemas, build_model_property
data = oai.Schema(properties={
"bad": oai.Schema(type="not_real"),
}, )
schemas = Schemas()
err, new_schemas = build_model_property(data=data,
name="prop",
schemas=schemas,
required=True,
parent_name=None,
config=MagicMock())
assert new_schemas == schemas
assert err == PropertyError(detail="unknown type not_real",
data=oai.Schema(type="not_real"))
def test_bad_additional_props_return_error(self):
from openapi_python_client.parser.properties import Config, Schemas, build_model_property
additional_properties = oai.Schema(
type="object",
properties={
"bad": oai.Schema(type="not_real"),
},
)
data = oai.Schema(additionalProperties=additional_properties)
schemas = Schemas()
err, new_schemas = build_model_property(data=data,
name="prop",
schemas=schemas,
required=True,
parent_name=None,
config=Config())
assert new_schemas == schemas
assert err == PropertyError(detail="unknown type not_real",
data=oai.Schema(type="not_real"))
def test_get_type_string(self):
from openapi_python_client.parser.properties import StringProperty
p = StringProperty(name="test", required=True, default=None, nullable=False)
base_type_string = f"str"
assert p.get_type_string() == base_type_string
assert p.get_type_string(json=True) == base_type_string
p = StringProperty(name="test", required=True, default=None, nullable=True)
assert p.get_type_string() == f"Optional[{base_type_string}]"
p = StringProperty(name="test", required=False, default=None, nullable=True)
assert p.get_type_string() == f"Union[Unset, None, {base_type_string}]"
p = StringProperty(name="test", required=False, default=None, nullable=False)
assert p.get_type_string() == f"Union[Unset, {base_type_string}]"
build_schemas(components=in_data)
build_enum_property.assert_called()
build_model_property.assert_not_called()
@pytest.mark.parametrize(
"additional_properties_schema, expected_additional_properties",
[
(True, True),
(oai.Schema.construct(), True),
(None, True),
(False, False),
(
oai.Schema.construct(type="string"),
StringProperty(name="AdditionalProperty", required=True, nullable=False, default=None),
),
],
)
def test_build_model_property(additional_properties_schema, expected_additional_properties):
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,
def _factory(**kwargs):
kwargs = _common_kwargs(kwargs)
return StringProperty(**kwargs)
