def test_dict_validate_from_openapi_data_instantiation(self):
expected_call_by_index = {
0: [
Foo, (frozendict({'bar': 'a'}), ),
InstantiationMetadata(path_to_item=('args[0]', ),
from_server=True)
],
1: [
StrSchema, ('a', ),
InstantiationMetadata(path_to_item=('args[0]', 'bar'),
from_server=True)
]
}
call_index = 0
result_by_call_index = {
0: defaultdict(set, [(('args[0]', ), set([Foo, frozendict]))]),
1: defaultdict(set, [(('args[0]', 'bar'), set([StrSchema, str]))]),
}
@classmethod
def new_validate(cls,
*args,
_instantiation_metadata: typing.
Optional[InstantiationMetadata] = None):
nonlocal call_index
assert [cls, args, _instantiation_metadata
] == expected_call_by_index[call_index]
result = result_by_call_index.get(call_index)
call_index += 1
if result is None:
raise petstore_api.ApiValueError('boom')
return result
with patch.object(Schema, '_validate', new=new_validate):
Foo._from_openapi_data({'bar': 'a'})
def test_dict_validate_direct_instantiation_cast_item(self):
expected_call_by_index = {
0: [
Foo,
(frozendict({"bar": "a"}), ),
ValidationMetadata(path_to_item=("args[0]", )),
],
}
call_index = 0
result_by_call_index = {
0: defaultdict(set, [(("args[0]", ), set([Foo, frozendict]))]),
}
@classmethod
def new_validate(
cls,
*args,
validation_metadata: typing.Optional[ValidationMetadata] = None,
):
nonlocal call_index
assert [cls, args,
validation_metadata] == expected_call_by_index[call_index]
result = result_by_call_index.get(call_index)
call_index += 1
if result is None:
raise petstore_api.ApiValueError("boom")
return result
bar = StrSchema("a")
with patch.object(Schema, "_validate", new=new_validate):
Foo(bar=bar)
def test_oneof_composition_pig_validate(self):
im = InstantiationMetadata()
path_to_schemas = Pig._validate(frozendict(className='DanishPig'),
_instantiation_metadata=im)
assert path_to_schemas == {
('args[0]', ):
set([Pig, DanishPig, frozendict]),
('args[0]', 'className'):
set([DanishPig.className, AnyTypeSchema, str]),
}
def test_discriminated_dict_validate(self):
im = InstantiationMetadata()
path_to_schemas = Animal._validate(frozendict(className='Dog',
color='black'),
_instantiation_metadata=im)
assert path_to_schemas == {
('args[0]', ): set([Animal, Dog, DogAllOf, frozendict]),
('args[0]', 'className'): set([StrSchema, AnyTypeSchema, str]),
('args[0]', 'color'): set([StrSchema, AnyTypeSchema, str]),
}
def test_oneof_composition_pig_validate(self):
vm = ValidationMetadata()
path_to_schemas = Pig._validate(frozendict(className="DanishPig"),
validation_metadata=vm)
assert path_to_schemas == {
("args[0]", ):
set([Pig, DanishPig, frozendict]),
("args[0]", "className"):
set([DanishPig.className, AnyTypeSchema, str]),
}
def test_discriminated_dict_validate(self):
vm = ValidationMetadata()
path_to_schemas = Animal._validate(frozendict(className="Dog",
color="black"),
validation_metadata=vm)
assert path_to_schemas == {
("args[0]", ): set([Animal, Dog, DogAllOf, frozendict]),
("args[0]", "className"): set([StrSchema, AnyTypeSchema, str]),
("args[0]", "color"): set([StrSchema, AnyTypeSchema, str]),
}
def test_anyof_composition_gm_fruit_validate(self):
im = InstantiationMetadata()
path_to_schemas = GmFruit._validate(frozendict(
cultivar='GoldenDelicious', lengthCm=Decimal(10)),
_instantiation_metadata=im)
assert path_to_schemas == {
('args[0]', ): set([GmFruit, Apple, Banana, frozendict]),
('args[0]', 'cultivar'): set([Apple.cultivar, AnyTypeSchema, str]),
('args[0]', 'lengthCm'):
set([AnyTypeSchema, NumberSchema, Decimal]),
}
def test_dict_validate(self):
im = InstantiationMetadata()
path_to_schemas = Foo._validate(frozendict({
'bar': 'a',
'additional': Decimal(0)
}),
_instantiation_metadata=im)
assert path_to_schemas == {
('args[0]', ): set([Foo, frozendict]),
('args[0]', 'bar'): set([StrSchema, str]),
('args[0]', 'additional'): set([AnyTypeSchema, Decimal])
}
def test_anyof_composition_gm_fruit_validate(self):
vm = ValidationMetadata()
path_to_schemas = GmFruit._validate(
frozendict(cultivar="GoldenDelicious", lengthCm=Decimal(10)),
validation_metadata=vm,
)
assert path_to_schemas == {
("args[0]", ): set([GmFruit, Apple, Banana, frozendict]),
("args[0]", "cultivar"): set([Apple.cultivar, AnyTypeSchema, str]),
("args[0]", "lengthCm"):
set([AnyTypeSchema, NumberSchema, Decimal]),
}
def test_dict_validate(self):
vm = ValidationMetadata()
path_to_schemas = Foo._validate(
frozendict({
"bar": "a",
"additional": Decimal(0)
}),
validation_metadata=vm,
)
assert path_to_schemas == {
("args[0]", ): set([Foo, frozendict]),
("args[0]", "bar"): set([StrSchema, str]),
("args[0]", "additional"): set([AnyTypeSchema, Decimal]),
}
def testDictSchema(self):
class Model(ComposedSchema):
@classmethod
@property
def _composed_schemas(cls):
return {
'allOf': [
AnyTypeSchema,
DictSchema,
],
'oneOf': [],
'anyOf': [],
}
m = Model(a=1, b='hi')
assert isinstance(m, Model)
assert isinstance(m, AnyTypeSchema)
assert isinstance(m, DictSchema)
assert isinstance(m, frozendict)
assert m == frozendict(a=Decimal(1), b='hi')
def test_empty_dict_validate(self):
im = InstantiationMetadata()
path_to_schemas = Foo._validate(frozendict({}),
_instantiation_metadata=im)
assert path_to_schemas == {('args[0]', ): set([Foo, frozendict])}
def test_empty_dict_validate(self):
vm = ValidationMetadata()
path_to_schemas = Foo._validate(frozendict({}), validation_metadata=vm)
assert path_to_schemas == {("args[0]", ): set([Foo, frozendict])}
def test_FormatTest(self):
"""Test FormatTest"""
required_args = dict(number=32.5,
byte='a',
date='2021-01-01',
password='******')
# int32
# under min
with self.assertRaises(petstore_api.ApiValueError):
model = FormatTest(int32=-2147483649, **required_args)
# over max
with self.assertRaises(petstore_api.ApiValueError):
model = FormatTest(int32=2147483648, **required_args)
# valid values in range work
valid_values = [-2147483648, 2147483647]
for valid_value in valid_values:
model = FormatTest(int32=valid_value, **required_args)
assert model.int32 == valid_value
# int64
# under min
with self.assertRaises(petstore_api.ApiValueError):
model = FormatTest(int64=-9223372036854775809, **required_args)
# over max
with self.assertRaises(petstore_api.ApiValueError):
model = FormatTest(int64=9223372036854775808, **required_args)
# valid values in range work
valid_values = [-9223372036854775808, 9223372036854775807]
for valid_value in valid_values:
model = FormatTest(int64=valid_value, **required_args)
assert model.int64 == valid_value
# float32
# under min
with self.assertRaises(petstore_api.ApiValueError):
model = FormatTest(float32=-3.402823466385289e+38, **required_args)
# over max
with self.assertRaises(petstore_api.ApiValueError):
model = FormatTest(float32=3.402823466385289e+38, **required_args)
# valid values in range work
valid_values = [-3.4028234663852886e+38, 3.4028234663852886e+38]
for valid_value in valid_values:
model = FormatTest(float32=valid_value, **required_args)
assert model.float32 == valid_value
# float64
# under min, Decimal is used because flat can only store 64bit numbers and the max and min
# take up more space than 64bit
with self.assertRaises(petstore_api.ApiValueError):
model = FormatTest(float64=Decimal('-1.7976931348623157082e+308'),
**required_args)
# over max
with self.assertRaises(petstore_api.ApiValueError):
model = FormatTest(float64=Decimal('1.7976931348623157082e+308'),
**required_args)
valid_values = [-1.7976931348623157E+308, 1.7976931348623157E+308]
for valid_value in valid_values:
model = FormatTest(float64=valid_value, **required_args)
assert model.float64 == valid_value
# unique_items with duplicates throws exception
with self.assertRaises(petstore_api.ApiValueError):
model = FormatTest(arrayWithUniqueItems=[0, 1, 1], **required_args)
# no duplicates works
values = [0, 1, 2]
model = FormatTest(arrayWithUniqueItems=values, **required_args)
assert model.arrayWithUniqueItems == tuple(values)
# __bool__ value of noneProp is False
model = FormatTest(noneProp=None, **required_args)
assert isinstance(model.noneProp, Singleton)
self.assertFalse(model.noneProp)
self.assertTrue(model.noneProp.is_none())
# binary check
model = FormatTest(binary=b'123', **required_args)
assert isinstance(model.binary, BinarySchema)
assert isinstance(model.binary, BytesSchema)
assert isinstance(model.binary, bytes)
assert model == frozendict(binary=b'123',
number=Decimal(32.5),
byte='a',
date='2021-01-01',
password='******')
