def test_value_is_not_dict_like_raises_error(petstore_dict):
petstore_spec = Spec.from_dict(petstore_dict)
pet_spec = petstore_spec.spec_dict['definitions']['Pet']
value = 'i am not a dict'
with pytest.raises(SwaggerMappingError) as excinfo:
marshal_model(petstore_spec, pet_spec, value)
assert "Expected type to be dict or Model to marshal value '{}' to a dict. Was {} instead.".format(
value,
type(value),
) in str(excinfo.value)
def test_marshal_model_raises_exception_if_different_model(petstore_spec):
pet_spec = petstore_spec.spec_dict['definitions']['Pet']
order_spec = petstore_spec.definitions['Order']
model = order_spec()
with pytest.raises(SwaggerMappingError) as excinfo:
marshal_model(petstore_spec, pet_spec, model)
assert str(
excinfo.value
) == 'Expected model of type {0} but got {1} for value {2}'.format(
'Pet',
'Order',
model,
)
def _marshal(self):
"""Marshal into a json-like dict.
:rtype: dict
"""
from bravado_core.marshal import marshal_model
return marshal_model(self._swagger_spec, self._model_spec, self)
def _marshal(self):
"""Marshal into a json-like dict.
:rtype: dict
"""
from bravado_core.marshal import marshal_model
return marshal_model(self._swagger_spec, self._model_spec, self)
def model_to_json(self, object):
"""Take a model instance and return it as a json struct"""
model_name = type(object).__name__
if model_name not in self.swagger_dict['definitions']:
raise ValidationError("Swagger spec has no definition for model %s" % model_name)
model_def = self.swagger_dict['definitions'][model_name]
log.debug("Marshalling %s into json" % model_name)
return marshal_model(self.spec, model_def, object)
def test_marshal_model_with_with_different_specs(petstore_dict, petstore_spec):
pet_spec = petstore_spec.spec_dict['definitions']['Pet']
new_petstore_spec = Spec.from_dict(petstore_dict)
model = new_petstore_spec.definitions['Pet'](
id=1,
name='Fido',
status=None,
photoUrls=['wagtail.png', 'bark.png'],
category=None,
tags=None
)
assert marshal_model(petstore_spec, pet_spec, model) == {
'id': 1, 'name': 'Fido', 'photoUrls': ['wagtail.png', 'bark.png'],
}
def test_pet(petstore_dict):
petstore_spec = Spec.from_dict(petstore_dict)
Pet = petstore_spec.definitions['Pet']
Category = petstore_spec.definitions['Category']
Tag = petstore_spec.definitions['Tag']
pet_spec = petstore_spec.spec_dict['definitions']['Pet']
pet = Pet(
id=1,
name='Fido',
status='sold',
photoUrls=['wagtail.png', 'bark.png'],
category=Category(id=200, name='friendly'),
tags=[
Tag(id=99, name='mini'),
Tag(id=100, name='brown')
]
)
result = marshal_model(petstore_spec, pet_spec, pet)
expected = {
'id': 1,
'name': 'Fido',
'status': 'sold',
'photoUrls': [
'wagtail.png',
'bark.png',
],
'category': {
'id': 200,
'name': 'friendly',
},
'tags': [
{
'id': 99,
'name': 'mini',
},
{
'id': 100,
'name': 'brown',
},
]
}
assert expected == result
def test_marshal_model_polymorphic_specs(polymorphic_spec):
PetList = polymorphic_spec.definitions['PetList']
Dog = polymorphic_spec.definitions['Dog']
Cat = polymorphic_spec.definitions['Cat']
list_of_pets_model = PetList(
number_of_pets=2,
list=[
Dog(
name='a dog name',
type='Dog',
birth_date=datetime.date(2017, 3, 9),
),
Cat(
name='a cat name',
type='Cat',
color='white',
),
],
)
polymorphic_spec.config['use_models'] = True
pet_list = marshal_model(
swagger_spec=polymorphic_spec,
model_spec=polymorphic_spec.spec_dict['definitions']['PetList'],
model_value=list_of_pets_model,
)
assert pet_list == {
'number_of_pets':
2,
'list': [
{
'name': 'a dog name',
'type': 'Dog',
'birth_date': '2017-03-09',
},
{
'name': 'a cat name',
'type': 'Cat',
'color': 'white',
},
],
}
def test_attrs_set_to_None_are_absent_from_result(petstore_dict):
# to recap: "required": ["name","photoUrls"]
petstore_spec = Spec.from_dict(petstore_dict)
Pet = petstore_spec.definitions['Pet']
pet_spec = petstore_spec.spec_dict['definitions']['Pet']
pet = Pet(id=1,
name='Fido',
status=None,
photoUrls=['wagtail.png', 'bark.png'],
category=None,
tags=None)
result = marshal_model(petstore_spec, pet_spec, pet)
expected = {
'id': 1,
'name': 'Fido',
'photoUrls': [
'wagtail.png',
'bark.png',
],
}
assert expected == result
def create_model_type(swagger_spec, model_name, model_spec):
"""Create a dynamic class from the model data defined in the swagger
spec.
The docstring for this class is dynamically generated because generating
the docstring is relatively expensive, and would only be used in rare
cases for interactive debugging in a REPL.
:type swagger_spec: :class:`bravado_core.spec.Spec`
:param model_name: model name
:param model_spec: json-like dict that describes a model.
:returns: dynamic type created with attributes, docstrings attached
:rtype: type
"""
from bravado_core.marshal import marshal_model
from bravado_core.unmarshal import unmarshal_model
doc = docstring_property(
partial(create_model_docstring, swagger_spec, model_spec))
def create(cls, kwargs):
self = cls.__new__(cls)
model_constructor(self, model_spec, swagger_spec, kwargs)
return self
methods = dict(
__doc__=doc,
__eq__=lambda self, other: compare(self, other),
__init__=lambda self, **kwargs: model_constructor(
self, model_spec, swagger_spec, kwargs),
__repr__=lambda self: create_model_repr(self, model_spec, swagger_spec
),
__dir__=lambda self: model_dir(self, model_spec, swagger_spec),
create=classmethod(create),
marshal=lambda self: marshal_model(swagger_spec, model_spec, self),
unmarshal=staticmethod(
lambda val: unmarshal_model(swagger_spec, model_spec, val)),
)
return type(str(model_name), (object, ), methods)
def test_attrs_set_to_None_are_absent_from_result(petstore_dict):
# to recap: "required": ["name","photoUrls"]
petstore_spec = Spec.from_dict(petstore_dict)
Pet = petstore_spec.definitions['Pet']
pet_spec = petstore_spec.spec_dict['definitions']['Pet']
pet = Pet(
id=1,
name='Fido',
status=None,
photoUrls=['wagtail.png', 'bark.png'],
category=None,
tags=None
)
result = marshal_model(petstore_spec, pet_spec, pet)
expected = {
'id': 1,
'name': 'Fido',
'photoUrls': [
'wagtail.png',
'bark.png',
],
}
assert expected == result
def test_value_is_not_dict_like_raises_error(petstore_dict):
petstore_spec = Spec.from_dict(petstore_dict)
pet_spec = petstore_spec.spec_dict['definitions']['Pet']
with pytest.raises(SwaggerMappingError) as excinfo:
marshal_model(petstore_spec, pet_spec, 'i am not a dict')
assert 'Expected model of type' in str(excinfo.value)
def test_marshal_nullable_model(petstore_spec):
pet_spec = copy.deepcopy(petstore_spec.spec_dict['definitions']['Pet'])
pet_spec['x-nullable'] = True
assert marshal_model(petstore_spec, pet_spec, None) is None
def test_marshal_model_with_none_model_type(petstore_spec):
model_spec = {'x-model': 'Foobar'}
with pytest.raises(SwaggerMappingError) as excinfo:
marshal_model(petstore_spec, model_spec, object())
assert 'Unknown model Foobar' in str(excinfo.value)
def test_value_is_not_dict_like_raises_error(petstore_dict):
petstore_spec = Spec.from_dict(petstore_dict)
pet_spec = petstore_spec.spec_dict['definitions']['Pet']
with pytest.raises(SwaggerMappingError) as excinfo:
marshal_model(petstore_spec, pet_spec, 'i am not a dict')
assert 'Expected {0.__module__}.{0.__name__} object but got '.format(Model) in str(excinfo.value)
def test_value_is_not_dict_like_raises_TypeError(petstore_dict):
petstore_spec = Spec.from_dict(petstore_dict)
pet_spec = petstore_spec.spec_dict['definitions']['Pet']
with pytest.raises(TypeError) as excinfo:
marshal_model(petstore_spec, pet_spec, 'i am not a dict')
assert 'Expected model of type' in str(excinfo.value)
def test_marshal_non_nullable_model(petstore_spec):
pet_spec = petstore_spec.spec_dict['definitions']['Pet']
with pytest.raises(SwaggerMappingError) as excinfo:
marshal_model(petstore_spec, pet_spec, None)
assert 'is a required value' in str(excinfo.value)
