def test_marshal_raises_SwaggerMappingError_if_SwaggerFormat_fails_during_to_wire(
minimal_swagger_dict):
minimal_swagger_dict['definitions']['test'] = {
'properties': {
'date': {
'type': 'string',
'format': 'date',
},
},
'required': [
'date',
],
'type': 'object'
}
swagger_spec = Spec(minimal_swagger_dict)
date_str = datetime.date.today().isoformat()
with pytest.raises(SwaggerMappingError) as excinfo:
marshal_schema_object(
swagger_spec=swagger_spec,
schema_object_spec=minimal_swagger_dict['definitions']['test'],
value={'date': date_str},
)
message, wrapped_exception = excinfo.value.args
assert message == 'Error while marshalling value={} to type=string/date.'.format(
date_str)
assert type(wrapped_exception) is AttributeError
assert wrapped_exception.args == (
'\'str\' object has no attribute \'isoformat\'', )
def test_marshal_raises_SwaggerMappingError_if_SwaggerFormat_fails_during_to_wire(minimal_swagger_dict):
minimal_swagger_dict['definitions']['test'] = {
'properties': {
'date': {
'type': 'string',
'format': 'date',
},
},
'required': [
'date',
],
'type': 'object'
}
swagger_spec = Spec(minimal_swagger_dict)
date_str = datetime.date.today().isoformat()
with pytest.raises(SwaggerMappingError) as excinfo:
marshal_schema_object(
swagger_spec=swagger_spec,
schema_object_spec=minimal_swagger_dict['definitions']['test'],
value={'date': date_str},
)
message, wrapped_exception = excinfo.value.args
assert message == 'Error while marshalling value={} to type=string/date.'.format(date_str)
assert type(wrapped_exception) is AttributeError
assert wrapped_exception.args == ('\'str\' object has no attribute \'isoformat\'', )
def test_defaultdicts_can_be_used_instead_of_models(petstore_dict):
petstore_spec = Spec.from_dict(petstore_dict)
pet_spec = petstore_spec.spec_dict['definitions']['Pet']
pet = defaultdict(
None, {
'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'
},
],
})
expected = copy.deepcopy(pet)
result = marshal_schema_object(petstore_spec, pet_spec, pet)
assert expected == result
def _marshal_object(self, request, response_object):
# operation attribute is injected by validator_tween in case the endpoint is served by Swagger 2.0 specs
operation = getattr(request, 'operation', None)
if not operation:
# If the request is not served by Swagger2.0 endpoint _marshal_object is NO_OP
return response_object
try:
response_spec = get_response_spec(
status_code=request.response.status_code,
op=request.operation,
)
return marshal_schema_object(
swagger_spec=request.registry.
settings['pyramid_swagger.schema20'],
schema_object_spec=response_spec['schema'],
value=response_object,
)
except MatchingResponseNotFound:
# Response specs not found
return response_object
except SwaggerMappingError:
# marshaling process failed
return response_object
def _marshal(self):
"""Marshal into a json-like dict.
:rtype: dict
"""
from bravado_core.marshal import marshal_schema_object
return marshal_schema_object(self._swagger_spec, self._model_spec,
self)
def marshal_param(param, value, request):
"""Given an operation's parameter and its value, marshal the value and
place it in the proper request destination.
Destination is one of:
- path - can accept primitive and array of primitive types
- query - can accept primitive and array of primitive types
- header - can accept primitive and array of primitive types
- body - can accept any type
- formData - can accept primitive and array of primitive types
:type param: :class:`bravado_core.param.Param`
:param value: The value to assign to the parameter
:type request: dict
"""
swagger_spec = param.swagger_spec
deref = swagger_spec.deref
param_spec = deref(get_param_type_spec(param))
location = param.location
# Rely on unmarshalling behavior on the other side of the pipe to use
# the default value if one is available.
if value is None and not param.required:
return
value = marshal_schema_object(swagger_spec, param_spec, value)
if swagger_spec.config['validate_requests']:
validate_schema_object(swagger_spec, param_spec, value)
param_type = param_spec.get('type')
if param_type == 'array' and location != 'body':
value = marshal_collection_format(swagger_spec, param_spec, value)
encode_param = partial(encode_request_param, param_type, param.name)
if location == 'path':
token = u'{%s}' % param.name
quoted_value = quote(six.text_type(value).encode('utf8'), safe=',')
request['url'] = request['url'].replace(token, quoted_value)
elif location == 'query':
request['params'][param.name] = encode_param(value)
elif location == 'header':
request['headers'][param.name] = encode_param(value)
elif location == 'formData':
if param_type == 'file':
add_file(param, value, request)
else:
request.setdefault('data', {})[param.name] = value
elif location == 'body':
request['headers']['Content-Type'] = APP_JSON
request['data'] = json.dumps(value)
else:
raise SwaggerMappingError(
"Don't know how to marshal_param with location {0}".
format(location))
def test_allOf_with_ref(composition_spec):
pongclone_spec = composition_spec.spec_dict['definitions']['pongClone']
value = {
'additionalFeature': 'Badges',
'gameSystem': 'NES',
'pang': 'value',
'releaseDate': 'October',
}
expected = copy.deepcopy(value)
assert expected == marshal_schema_object(composition_spec, pongclone_spec, value)
def test_allOf_with_ref(composition_spec):
pongclone_spec = composition_spec.spec_dict['definitions']['pongClone']
value = {
'additionalFeature': 'Badges',
'gameSystem': 'NES',
'pang': 'value',
'releaseDate': 'October',
}
expected = copy.deepcopy(value)
assert expected == marshal_schema_object(composition_spec, pongclone_spec, value)
def marshal_param(param, value, request):
"""Given an operation's parameter and its value, marshal the value and
place it in the proper request destination.
Destination is one of:
- path - can accept primitive and array of primitive types
- query - can accept primitive and array of primitive types
- header - can accept primitive and array of primitive types
- body - can accept any type
- formData - can accept primitive and array of primitive types
:type param: :class:`bravado_core.param.Param`
:param value: The value to assign to the parameter
:type request: dict
"""
swagger_spec = param.swagger_spec
deref = swagger_spec.deref
param_spec = deref(get_param_type_spec(param))
location = param.location
# Rely on unmarshalling behavior on the other side of the pipe to use
# the default value if one is availabe.
if value is None and not schema.is_required(swagger_spec, param_spec):
return
value = marshal_schema_object(swagger_spec, param_spec, value)
if swagger_spec.config['validate_requests']:
validate_schema_object(swagger_spec, param_spec, value)
param_type = param_spec.get('type')
if param_type == 'array' and location != 'body':
value = marshal_collection_format(swagger_spec, param_spec, value)
if location == 'path':
token = u'{%s}' % param.name
# Don't do any escaping/encoding - http_client will take care of it
request['url'] = request['url'].replace(token, six.text_type(value))
elif location == 'query':
request['params'][param.name] = value
elif location == 'header':
request['headers'][param.name] = value
elif location == 'formData':
if param_type == 'file':
add_file(param, value, request)
else:
request.setdefault('data', {})[param.name] = value
elif location == 'body':
request['headers']['Content-Type'] = APP_JSON
request['data'] = json.dumps(value)
else:
raise SwaggerMappingError(
"Don't know how to marshal_param with location {0}".
format(location))
def marshal_param(param, value, request):
"""Given an operation's parameter and its value, marshal the value and
place it in the proper request destination.
Destination is one of:
- path - can accept primitive and array of primitive types
- query - can accept primitive and array of primitive types
- header - can accept primitive and array of primitive types
- body - can accept any type
- formData - can accept primitive and array of primitive types
:type param: :class:`bravado_core.param.Param`
:param value: The value to assign to the parameter
:type request: dict
"""
swagger_spec = param.swagger_spec
deref = swagger_spec.deref
spec = deref(get_param_type_spec(param))
location = param.location
value = marshal_schema_object(swagger_spec, spec, value)
if swagger_spec.config['validate_requests']:
validate_schema_object(swagger_spec, spec, value)
param_type = spec.get('type')
if param_type == 'array' and location != 'body':
value = marshal_collection_format(swagger_spec, spec, value)
if location == 'path':
token = u'{%s}' % param.name
# Don't do any escaping/encoding - http_client will take care of it
request['url'] = request['url'].replace(token, six.text_type(value))
elif location == 'query':
request['params'][param.name] = value
elif location == 'header':
request['headers'][param.name] = value
elif location == 'formData':
if param_type == 'file':
add_file(param, value, request)
else:
request.setdefault('data', {})[param.name] = value
elif location == 'body':
request['headers']['Content-Type'] = APP_JSON
request['data'] = json.dumps(value)
else:
raise SwaggerMappingError(
"Don't know how to marshal_param with location {0}".
format(location))
def parse_and_validate_parameters(raw_params):
initialize_specification()
clean_params = {}
for parameter in _parsed_spec.spec_dict['parameters']:
parameter_spec = _parsed_spec.spec_dict['parameters'][parameter]
parameter_type = parameter_spec['type']
parameter_name = parameter_spec['name']
try:
value = param.cast_request_param(parameter_type, parameter, raw_params.get(parameter_name))
validate.validate_schema_object(_parsed_spec, parameter_spec, value)
clean_params[parameter] = marshal.marshal_schema_object(_parsed_spec, parameter_spec, value)
except Exception as e:
raise ValueError(e)
return clean_params
def marshal_param(param, value, request):
"""
Given an operation parameter and its value, marshal the value and place it
in the proper request destination.
Destination is one of:
- path - can accept primitive and array of primitive types
- query - can accept primitive and array of primitive types
- header - can accept primitive and array of primitive types
- body - can accept any type
- formData - can accept primitive and array of primitive types
:type param: :class:`bravado_core.param.Param`
:param value: The value to assign to the parameter
:type request: dict
"""
spec = get_param_type_spec(param)
location = param.location
value = marshal_schema_object(param.swagger_spec, spec, value)
if param.swagger_spec.config['validate_requests']:
validate_schema_object(spec, value)
if spec['type'] == 'array' and location != 'body':
value = marshal_collection_format(spec, value)
if location == 'path':
token = u'{%s}' % param.name
request['url'] = \
request['url'].replace(token, urllib.quote(unicode(value)))
elif location == 'query':
request['params'][param.name] = value
elif location == 'header':
request['headers'][param.name] = value
elif location == 'formData':
if spec['type'] == 'file':
add_file(param, value, request)
else:
request.setdefault('data', {})[param.name] = value
elif location == 'body':
request['headers']['Content-Type'] = APP_JSON
request['data'] = json.dumps(value)
else:
raise SwaggerMappingError(
"Don't know how to marshal_param with location {0}".
format(location))
def test_defaultdicts_can_be_used_instead_of_models(petstore_dict):
petstore_spec = Spec.from_dict(petstore_dict)
pet_spec = petstore_spec.spec_dict['definitions']['Pet']
pet = defaultdict(None, {
'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'},
],
})
expected = copy.deepcopy(pet)
result = marshal_schema_object(petstore_spec, pet_spec, pet)
assert expected == result
def _marshal_object(self, request, response_object):
# operation attribute is injected by validator_tween in case the endpoint is served by Swagger 2.0 specs
operation = getattr(request, 'operation', None)
if not operation:
# If the request is not served by Swagger2.0 endpoint _marshal_object is NO_OP
return response_object
try:
response_spec = get_response_spec(
status_code=request.response.status_code,
op=request.operation,
)
return marshal_schema_object(
swagger_spec=request.registry.settings['pyramid_swagger.schema20'],
schema_object_spec=response_spec['schema'],
value=response_object,
)
except (MatchingResponseNotFound, SwaggerMappingError, KeyError):
# marshaling process failed
return response_object
def to_json(self, keep_datetime=False):
"""Return a json representation of this PyMacaron object - If keep_datetime is set,
will keep attributes that are datetime unchanged.
"""
log.debug("Marshalling %s into json" % getattr(self, '__model_name'))
datetimes = {}
if keep_datetime:
for k in self.__property_names:
if hasattr(self, k) and getattr(
self,
k).__class__.__name__ in ('datetime',
'DatetimeWithNanoseconds'):
datetimes[k] = getattr(self, k)
j = marshal_schema_object(
getattr(self, '__swagger_spec'),
getattr(self, '__swagger_dict'),
self.to_bravado(),
)
if datetimes:
j.update(datetimes)
return j
def test_ref(minimal_swagger_dict):
ref_spec = {'$ref': '#/refs/Foo'}
foo_spec = {'type': 'string'}
minimal_swagger_dict['refs'] = {'Foo': foo_spec}
swagger_spec = Spec(minimal_swagger_dict)
assert 'foo' == marshal_schema_object(swagger_spec, ref_spec, 'foo')
def test_unknown_type_raises_error(empty_swagger_spec):
invalid_spec = {'type': 'foo'}
with pytest.raises(SwaggerMappingError) as excinfo:
marshal_schema_object(empty_swagger_spec, invalid_spec, "don't matter")
assert 'Unknown type foo' in str(excinfo.value)
def marshal_response(recommendations):
initialize_specification()
articles_spec = _parsed_spec.spec_dict['definitions']['Articles']
articles = marshal.marshal_schema_object(_parsed_spec, articles_spec, {'articles': recommendations})
return articles
def test_ref(minimal_swagger_dict):
ref_spec = {'$ref': '#/refs/Foo'}
foo_spec = {'type': 'string'}
minimal_swagger_dict['refs'] = {'Foo': foo_spec}
swagger_spec = Spec(minimal_swagger_dict)
assert 'foo' == marshal_schema_object(swagger_spec, ref_spec, 'foo')
def test_unknown_type_raises_error(empty_swagger_spec):
invalid_spec = {'type': 'foo'}
with pytest.raises(SwaggerMappingError) as excinfo:
marshal_schema_object(empty_swagger_spec, invalid_spec, "don't matter")
assert 'Unknown type foo' in str(excinfo.value)
