def test_property_from_data_enum(self, mocker):
name = mocker.MagicMock()
required = mocker.MagicMock()
data = mocker.MagicMock(title=None)
EnumProperty = mocker.patch(f"{MODULE_NAME}.EnumProperty")
mocker.patch("openapi_python_client.utils.remove_string_escapes",
return_value=name)
from openapi_python_client.parser.properties import property_from_data
p = property_from_data(name=name, required=required, data=data)
EnumProperty.values_from_list.assert_called_once_with(data.enum)
EnumProperty.assert_called_once_with(
name=name,
required=required,
values=EnumProperty.values_from_list(),
default=data.default,
title=name)
assert p == EnumProperty()
EnumProperty.reset_mock()
data.title = mocker.MagicMock()
property_from_data(
name=name,
required=required,
data=data,
)
EnumProperty.assert_called_once_with(
name=name,
required=required,
values=EnumProperty.values_from_list(),
default=data.default,
title=data.title)
def test_property_from_data_simple_types(self, openapi_type, prop_type, python_type):
from openapi_python_client.parser.properties import Schemas, property_from_data
name = "test_prop"
required = True
data = oai.Schema.construct(type=openapi_type, default=1)
schemas = Schemas()
p, new_schemas = property_from_data(
name=name, required=required, data=data, schemas=schemas, parent_name="parent", config=MagicMock()
)
assert p == prop_type(name=name, required=required, default=python_type(data.default), nullable=False)
assert new_schemas == schemas
# Test nullable values
data.default = 0
data.nullable = True
p, _ = property_from_data(
name=name, required=required, data=data, schemas=schemas, parent_name="parent", config=MagicMock()
)
assert p == prop_type(name=name, required=required, default=python_type(data.default), nullable=True)
# Test bad default value
data.default = "a"
p, _ = property_from_data(
name=name, required=required, data=data, schemas=schemas, parent_name="parent", config=MagicMock()
)
assert python_type is bool or isinstance(p, PropertyError)
def test_property_from_data_simple_types(self, mocker, openapi_type,
python_type):
name = mocker.MagicMock()
required = mocker.MagicMock()
data = oai.Schema.construct(type=openapi_type)
clazz = mocker.patch(f"{MODULE_NAME}.{python_type}")
mocker.patch("openapi_python_client.utils.remove_string_escapes",
return_value=name)
from openapi_python_client.parser.properties import property_from_data
p = property_from_data(name=name, required=required, data=data)
clazz.assert_called_once_with(name=name,
required=required,
default=None)
assert p == clazz()
# Test optional values
clazz.reset_mock()
data.default = mocker.MagicMock()
property_from_data(
name=name,
required=required,
data=data,
)
clazz.assert_called_once_with(name=name,
required=required,
default=data.default)
def test_property_from_data_str_enum(self, mocker):
from openapi_python_client.parser.properties import Class, EnumProperty
from openapi_python_client.schema import Schema
data = Schema(title="AnEnum", enum=["A", "B", "C"], nullable=False, default="B")
name = "my_enum"
required = True
from openapi_python_client.parser.properties import Schemas, property_from_data
schemas = Schemas(classes_by_name={"AnEnum": mocker.MagicMock()})
prop, new_schemas = property_from_data(
name=name, required=required, data=data, schemas=schemas, parent_name="parent", config=Config()
)
assert prop == EnumProperty(
name="my_enum",
required=True,
nullable=False,
values={"A": "A", "B": "B", "C": "C"},
class_info=Class(name="ParentAnEnum", module_name="parent_an_enum"),
value_type=str,
default="ParentAnEnum.B",
)
assert schemas != new_schemas, "Provided Schemas was mutated"
assert new_schemas.classes_by_name == {
"AnEnum": schemas.classes_by_name["AnEnum"],
"ParentAnEnum": prop,
}
def test_property_from_data_union(self, mocker):
name = mocker.MagicMock()
required = mocker.MagicMock()
data = oai.Schema(
anyOf=[{"type": "number", "default": "0.0"}],
oneOf=[
{"type": "integer", "default": "0"},
],
)
UnionProperty = mocker.patch(f"{MODULE_NAME}.UnionProperty")
FloatProperty = mocker.patch(f"{MODULE_NAME}.FloatProperty")
IntProperty = mocker.patch(f"{MODULE_NAME}.IntProperty")
mocker.patch("openapi_python_client.utils.remove_string_escapes", return_value=name)
from openapi_python_client.parser.properties import Schemas, property_from_data
p, s = property_from_data(
name=name, required=required, data=data, schemas=Schemas(), parent_name="parent", config=MagicMock()
)
FloatProperty.assert_called_once_with(name=name, required=required, default=0.0, nullable=False)
IntProperty.assert_called_once_with(name=name, required=required, default=0, nullable=False)
UnionProperty.assert_called_once_with(
name=name,
required=required,
default=None,
inner_properties=[FloatProperty.return_value, IntProperty.return_value],
nullable=False,
)
assert p == UnionProperty.return_value
assert s == Schemas()
def test_property_from_data_int_enum(self, enum_property_factory):
from openapi_python_client.parser.properties import Class, Schemas, property_from_data
from openapi_python_client.schema import Schema
name = "my_enum"
required = True
nullable = False
data = Schema.construct(title="anEnum", enum=[1, 2, 3], nullable=nullable, default=3)
existing = enum_property_factory()
schemas = Schemas(classes_by_name={"AnEnum": existing})
prop, new_schemas = property_from_data(
name=name, required=required, data=data, schemas=schemas, parent_name="parent", config=Config()
)
assert prop == enum_property_factory(
name=name,
required=required,
nullable=nullable,
values={"VALUE_1": 1, "VALUE_2": 2, "VALUE_3": 3},
class_info=Class(name="ParentAnEnum", module_name="parent_an_enum"),
value_type=int,
default="ParentAnEnum.VALUE_3",
)
assert schemas != new_schemas, "Provided Schemas was mutated"
assert new_schemas.classes_by_name == {
"AnEnum": existing,
"ParentAnEnum": prop,
}
def test_property_from_data_union_of_one_element(self, mocker,
model_property_factory):
from openapi_python_client.parser.properties import Class, ModelProperty, Schemas, property_from_data
name = "new_name"
required = False
class_name = "MyModel"
nullable = True
existing_model = model_property_factory()
schemas = Schemas(
classes_by_reference={f"/{class_name}": existing_model})
data = oai.Schema.construct(
allOf=[oai.Reference.construct(ref=f"#/{class_name}")],
nullable=nullable,
)
build_union_property = mocker.patch(
f"{MODULE_NAME}.build_union_property")
prop, schemas = property_from_data(name=name,
required=required,
data=data,
schemas=schemas,
parent_name="parent",
config=Config())
assert prop == attr.evolve(existing_model,
name=name,
required=required,
nullable=nullable,
python_name=name)
build_union_property.assert_not_called()
def test_property_from_data_union(
self, union_property_factory, date_time_property_factory, string_property_factory
):
from openapi_python_client.parser.properties import Schemas, property_from_data
name = "union_prop"
required = True
data = oai.Schema(
anyOf=[{"type": "string", "default": "a"}],
oneOf=[
{"type": "string", "format": "date-time"},
],
)
expected = union_property_factory(
name=name,
required=required,
inner_properties=[
string_property_factory(name=f"{name}_type_0", default="'a'"),
date_time_property_factory(name=f"{name}_type_1"),
],
)
p, s = property_from_data(
name=name, required=required, data=data, schemas=Schemas(), parent_name="parent", config=MagicMock()
)
assert p == expected
assert s == Schemas()
def test_property_from_data_ref_model(self, model_property_factory):
from openapi_python_client.parser.properties import Class, ModelProperty, Schemas, property_from_data
name = "new_name"
required = False
class_name = "MyModel"
data = oai.Reference.construct(
ref=f"#/components/schemas/{class_name}")
class_info = Class(name=class_name, module_name="my_model")
existing_model = model_property_factory(
name="old_name",
class_info=class_info,
)
schemas = Schemas(classes_by_reference={
f"/components/schemas/{class_name}": existing_model
})
prop, new_schemas = property_from_data(name=name,
required=required,
data=data,
schemas=schemas,
parent_name="",
config=Config())
assert prop == model_property_factory(
name=name,
required=required,
class_info=class_info,
)
assert schemas == new_schemas
def test_property_from_data_ref_enum(self, enum_property_factory):
from openapi_python_client.parser.properties import Class, Schemas, property_from_data
name = "some_enum"
data = oai.Reference.construct(ref="#/components/schemas/MyEnum")
existing_enum = enum_property_factory(
name="an_enum",
required=False,
values={"A": "a"},
class_info=Class(name="MyEnum", module_name="my_enum"),
)
schemas = Schemas(
classes_by_reference={"/components/schemas/MyEnum": existing_enum})
prop, new_schemas = property_from_data(name=name,
required=False,
data=data,
schemas=schemas,
parent_name="",
config=Config())
assert prop == enum_property_factory(
name="some_enum",
required=False,
values={"A": "a"},
class_info=Class(name="MyEnum", module_name="my_enum"),
)
assert schemas == new_schemas
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()
config = MagicMock()
response = property_from_data(name=name,
required=required,
data=data,
schemas=schemas,
parent_name="parent",
config=config)
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",
config=config)
def test_property_from_data_str_enum_with_null(self, enum_property_factory):
from openapi_python_client.parser.properties import Class, Schemas, property_from_data
from openapi_python_client.schema import Schema
existing = enum_property_factory()
data = Schema(title="AnEnum", enum=["A", "B", "C", None], nullable=False, default="B")
name = "my_enum"
required = True
schemas = Schemas(classes_by_name={"AnEnum": existing})
prop, new_schemas = property_from_data(
name=name, required=required, data=data, schemas=schemas, parent_name="parent", config=Config()
)
# None / null is removed from enum, and property is now nullable
assert prop == enum_property_factory(
name=name,
required=required,
nullable=True,
values={"A": "A", "B": "B", "C": "C"},
class_info=Class(name="ParentAnEnum", module_name="parent_an_enum"),
value_type=str,
default="ParentAnEnum.B",
)
assert prop.nullable is True
assert schemas != new_schemas, "Provided Schemas was mutated"
assert new_schemas.classes_by_name == {
"AnEnum": existing,
"ParentAnEnum": prop,
}
def test_property_from_data_ref_enum(self):
from openapi_python_client.parser.properties import EnumProperty, Reference, Schemas, property_from_data
name = "some_enum"
data = oai.Reference.construct(ref="MyEnum")
existing_enum = EnumProperty(
name="an_enum",
required=True,
nullable=False,
default=None,
values={"A": "a"},
value_type=str,
reference=Reference(class_name="MyEnum", module_name="my_enum"),
)
schemas = Schemas(enums={"MyEnum": existing_enum})
prop, new_schemas = property_from_data(name=name, required=False, data=data, schemas=schemas, parent_name="")
assert prop == EnumProperty(
name="some_enum",
required=False,
nullable=False,
default=None,
values={"A": "a"},
value_type=str,
reference=Reference(class_name="MyEnum", module_name="my_enum"),
)
assert schemas == new_schemas
def test_property_from_data_ref_enum_with_invalid_default(
self, enum_property_factory):
from openapi_python_client.parser.properties import Class, Schemas, property_from_data
name = "some_enum"
data = oai.Schema.construct(
default="x",
allOf=[oai.Reference.construct(ref="#/components/schemas/MyEnum")])
existing_enum = enum_property_factory(
name="an_enum",
default="MyEnum.A",
values={
"A": "a",
"B": "b"
},
class_info=Class(name="MyEnum", module_name="my_enum"),
python_name="an_enum",
)
schemas = Schemas(
classes_by_reference={"/components/schemas/MyEnum": existing_enum})
prop, new_schemas = property_from_data(name=name,
required=False,
data=data,
schemas=schemas,
parent_name="",
config=Config())
assert schemas == new_schemas
assert prop == PropertyError(
data=data, detail="x is an invalid default for enum MyEnum")
def test_property_from_data_array(self, mocker):
name = mocker.MagicMock()
required = mocker.MagicMock()
data = oai.Schema(
type="array",
items={
"type": "number",
"default": "0.0"
},
)
ListProperty = mocker.patch(f"{MODULE_NAME}.ListProperty")
FloatProperty = mocker.patch(f"{MODULE_NAME}.FloatProperty")
mocker.patch("openapi_python_client.utils.remove_string_escapes",
return_value=name)
from openapi_python_client.parser.properties import property_from_data
p = property_from_data(name=name, required=required, data=data)
FloatProperty.assert_called_once_with(name=name,
required=True,
default="0.0")
ListProperty.assert_called_once_with(
name=name,
required=required,
default=None,
inner_property=FloatProperty.return_value)
assert p == ListProperty.return_value
def test_property_from_data_int_enum(self, mocker):
from openapi_python_client.parser.properties import EnumProperty, Reference
from openapi_python_client.schema import Schema
data = Schema.construct(title="anEnum", enum=[1, 2, 3], nullable=False, default=3)
name = "my_enum"
required = True
from openapi_python_client.parser.properties import Schemas, property_from_data
schemas = Schemas(enums={"AnEnum": mocker.MagicMock()})
prop, new_schemas = property_from_data(
name=name, required=required, data=data, schemas=schemas, parent_name="parent"
)
assert prop == EnumProperty(
name="my_enum",
required=True,
nullable=False,
values={"VALUE_1": 1, "VALUE_2": 2, "VALUE_3": 3},
reference=Reference(class_name="ParentAnEnum", module_name="parent_an_enum"),
value_type=int,
default="ParentAnEnum.VALUE_3",
)
assert schemas != new_schemas, "Provided Schemas was mutated"
assert new_schemas.enums == {
"AnEnum": schemas.enums["AnEnum"],
"ParentAnEnum": prop,
}
def test_property_from_data_no_valid_props_in_data(self):
from openapi_python_client.parser.errors import PropertyError
from openapi_python_client.parser.properties import property_from_data
data = oai.Schema()
assert property_from_data(name="blah", required=True, data=data) == PropertyError(
data=data, detail="Schemas must either have one of enum, anyOf, or type defined."
)
def test_property_from_data_validation_error(self, mocker):
from openapi_python_client.parser.errors import PropertyError
from openapi_python_client.parser.properties import property_from_data
mocker.patch(f"{MODULE_NAME}._property_from_data").side_effect = ValidationError()
data = oai.Schema()
assert property_from_data(name="blah", required=True, data=data) == PropertyError(
detail="Failed to validate default value", data=data
)
def test_property_from_data_array_no_items(self, mocker):
name = mocker.MagicMock()
required = mocker.MagicMock()
data = oai.Schema(type="array")
from openapi_python_client.parser.properties import property_from_data
p = property_from_data(name=name, required=required, data=data)
assert p == PropertyError(data=data, detail="type array must have items defined")
def test_property_from_data_unsupported_type(self, mocker):
name = mocker.MagicMock()
required = mocker.MagicMock()
data = oai.Schema.construct(type=mocker.MagicMock())
from openapi_python_client.parser.errors import PropertyError
from openapi_python_client.parser.properties import property_from_data
assert property_from_data(name=name, required=required, data=data) == PropertyError(
data=data, detail=f"unknown type {data.type}"
)
def test_property_from_data_array_invalid_items(self, mocker):
name = mocker.MagicMock()
required = mocker.MagicMock()
data = oai.Schema(type="array", items={},)
mocker.patch("openapi_python_client.utils.remove_string_escapes", return_value=name)
from openapi_python_client.parser.properties import property_from_data
p = property_from_data(name=name, required=required, data=data)
assert p == PropertyError(data=oai.Schema(), detail=f"invalid data in items of array {name}")
def test_property_from_data_union_bad_type(self, mocker):
name = mocker.MagicMock()
required = mocker.MagicMock()
data = oai.Schema(anyOf=[{}])
mocker.patch("openapi_python_client.utils.remove_string_escapes", return_value=name)
from openapi_python_client.parser.properties import property_from_data
p = property_from_data(name=name, required=required, data=data)
assert p == PropertyError(detail=f"Invalid property in union {name}", data=oai.Schema())
def test_property_from_data_union_bad_type(self, mocker):
name = "bad_union"
required = mocker.MagicMock()
data = oai.Schema(anyOf=[{"type": "garbage"}])
mocker.patch("openapi_python_client.utils.remove_string_escapes", return_value=name)
from openapi_python_client.parser.properties import Schemas, property_from_data
p, s = property_from_data(name=name, required=required, data=data, schemas=Schemas(), parent_name="parent")
assert p == PropertyError(detail=f"Invalid property in union {name}", data=oai.Schema(type="garbage"))
def test_property_from_data_no_valid_props_in_data(self):
from openapi_python_client.parser.properties import NoneProperty, Schemas, property_from_data
schemas = Schemas()
data = oai.Schema()
prop, new_schemas = property_from_data(
name="blah", required=True, data=data, schemas=schemas, parent_name="parent", config=MagicMock()
)
assert prop == NoneProperty(name="blah", required=True, nullable=False, default=None)
assert new_schemas == schemas
def test__string_based_property_binary_format(self, file_property_factory):
from openapi_python_client.parser.properties import property_from_data
name = "file_prop"
required = True
nullable = True
data = oai.Schema.construct(type="string", schema_format="binary", nullable=nullable, default="a")
p, _ = property_from_data(
name=name, required=required, data=data, schemas=Schemas(), config=Config(), parent_name=None
)
assert p == file_property_factory(name=name, required=required, nullable=nullable)
def test_datetime_bad_default(self):
from openapi_python_client.parser.properties import property_from_data
name = "datetime_prop"
required = True
data = oai.Schema.construct(type="string", schema_format="date-time", nullable=True, default="a")
result, _ = property_from_data(
name=name, required=required, data=data, schemas=Schemas(), config=Config(), parent_name=None
)
assert result == PropertyError(detail="Failed to validate default value", data=data)
def test_property_from_data_validation_error(self, mocker):
from openapi_python_client.parser.errors import PropertyError
from openapi_python_client.parser.properties import Schemas, property_from_data
mocker.patch(f"{MODULE_NAME}._property_from_data").side_effect = ValidationError()
schemas = Schemas()
data = oai.Schema()
err, new_schemas = property_from_data(
name="blah", required=True, data=data, schemas=schemas, parent_name="parent", config=MagicMock()
)
assert err == PropertyError(detail="Failed to validate default value", data=data)
assert new_schemas == schemas
def test__string_based_property_unsupported_format(self, string_property_factory):
from openapi_python_client.parser.properties import property_from_data
name = "unknown"
required = True
nullable = True
data = oai.Schema.construct(type="string", schema_format="blah", nullable=nullable)
p, _ = property_from_data(
name=name, required=required, data=data, schemas=Schemas, config=Config(), parent_name=None
)
assert p == string_property_factory(name=name, required=required, nullable=nullable)
def test_no_format(self, string_property_factory, nullable, required):
from openapi_python_client.parser.properties import property_from_data
name = "some_prop"
data = oai.Schema.construct(type="string", nullable=nullable, default='"hello world"', pattern="abcdef")
p, _ = property_from_data(
name=name, required=required, data=data, parent_name=None, config=Config(), schemas=Schemas()
)
assert p == string_property_factory(
name=name, required=required, nullable=nullable, default="'\\\\\"hello world\\\\\"'", pattern=data.pattern
)
def test_property_from_data_string(self, mocker):
_string_based_property = mocker.patch(f"{MODULE_NAME}._string_based_property")
name = mocker.MagicMock()
required = mocker.MagicMock()
data = oai.Schema.construct(type="string")
mocker.patch("openapi_python_client.utils.remove_string_escapes", return_value=name)
from openapi_python_client.parser.properties import property_from_data
p = property_from_data(name=name, required=required, data=data)
assert p == _string_based_property.return_value
_string_based_property.assert_called_once_with(name=name, required=required, data=data)