def test_required_query_array_with_no_value(empty_swagger_spec,
array_param_spec, request_dict):
array_param_spec['required'] = True
param = Param(empty_swagger_spec, Mock(spec=Operation), array_param_spec)
with pytest.raises(SwaggerMappingError) as excinfo:
marshal_param(param, value=None, request=request_dict)
assert 'is a required value' in str(excinfo.value)
def test_optional_query_array_with_no_value(empty_swagger_spec,
array_param_spec, request_dict):
array_param_spec['required'] = False
param = Param(empty_swagger_spec, Mock(spec=Operation), array_param_spec)
expected = copy.deepcopy(request_dict)
marshal_param(param, value=None, request=request_dict)
assert expected == request_dict
def test_path_integer(empty_swagger_spec, param_spec):
param_spec["in"] = "path"
param = Param(empty_swagger_spec, Mock(spec=Operation), param_spec)
request = {"url": "/pet/{petId}"}
marshal_param(param, 34, request)
# verify integer coerceced to str
assert "/pet/34" == request["url"]
def test_query_array(empty_swagger_spec, array_param_spec, request_dict):
param = Param(empty_swagger_spec, Mock(spec=Operation), array_param_spec)
value = ["cat", "dog", "bird"]
expected = copy.deepcopy(request_dict)
expected["params"]["animals"] = ",".join(value)
marshal_param(param, value, request_dict)
assert expected == request_dict
def test_path_integer(empty_swagger_spec, param_spec):
param_spec['in'] = 'path'
param = Param(empty_swagger_spec, Mock(spec=Operation), param_spec)
request = {'url': '/pet/{petId}'}
marshal_param(param, 34, request)
# verify integer coerceced to str
assert '/pet/34' == request['url']
def test_query_array(empty_swagger_spec, array_param_spec, request_dict):
param = Param(empty_swagger_spec, Mock(spec=Operation), array_param_spec)
value = ['cat', 'dog', 'bird']
expected = copy.deepcopy(request_dict)
expected['params']['animals'] = ','.join(value)
marshal_param(param, value, request_dict)
assert expected == request_dict
def construct_params(self, request, op_kwargs):
"""
Given the parameters passed to the operation invocation, validates and
marshals the parameters into the provided request dict.
:type request: dict
:param op_kwargs: the kwargs passed to the operation invocation
:raises: SwaggerMappingError on extra parameters or when a required
parameter is not supplied.
"""
current_params = self.operation.params.copy()
for param_name, param_value in iteritems(op_kwargs):
param = current_params.pop(param_name, None)
if param is None:
raise SwaggerMappingError(
"{0} does not have parameter {1}"
.format(self.operation.operation_id, param_name))
marshal_param(param, param_value, request)
# Check required params and non-required params with a 'default' value
for remaining_param in itervalues(current_params):
if remaining_param.required:
raise SwaggerMappingError(
'{0} is a required parameter'.format(remaining_param.name))
if not remaining_param.required and remaining_param.has_default():
marshal_param(remaining_param, None, request)
def test_formData_file(empty_swagger_spec, param_spec, request_dict):
param_spec["in"] = "formData"
param_spec["type"] = "file"
param = Param(empty_swagger_spec, Mock(spec=Operation, consumes=["multipart/form-data"]), param_spec)
marshal_param(param, "i am the contents of a file", request_dict)
expected = {"params": {}, "files": [("petId", ("petId", "i am the contents of a file"))]}
assert expected == request_dict
def test_header_string(empty_swagger_spec, param_spec):
param_spec['in'] = 'header'
param_spec['type'] = 'string'
del param_spec['format']
param = Param(empty_swagger_spec, Mock(spec=Operation), param_spec)
request = {'headers': {}}
marshal_param(param, '34', request)
assert {'petId': '34'} == request['headers']
def test_path_string(empty_swagger_spec, param_spec):
param_spec["in"] = "path"
param_spec["type"] = "string"
del param_spec["format"]
param = Param(empty_swagger_spec, Mock(spec=Operation), param_spec)
request = {"url": "/pet/{petId}"}
marshal_param(param, "34", request)
assert "/pet/34" == request["url"]
def assert_validate_call_count(expected_call_count, config, petstore_dict):
with patch("bravado_core.param.validate_schema_object") as m_validate:
petstore_spec = Spec.from_dict(petstore_dict, config=config)
request = {"url": "/pet/{petId}"}
op = petstore_spec.resources["pet"].operations["getPetById"]
param = op.params["petId"]
marshal_param(param, 34, request)
assert expected_call_count == m_validate.call_count
def test_path_string(empty_swagger_spec, param_spec):
param_spec['in'] = 'path'
param_spec['type'] = 'string'
del param_spec['format']
param = Param(empty_swagger_spec, Mock(spec=Operation), param_spec)
request = {'url': '/pet/{petId}'}
marshal_param(param, '34', request)
assert '/pet/34' == request['url']
def test_header_string(empty_swagger_spec, param_spec):
param_spec["in"] = "header"
param_spec["type"] = "string"
del param_spec["format"]
param = Param(empty_swagger_spec, Mock(spec=Operation), param_spec)
request = {"headers": {}}
marshal_param(param, "34", request)
assert {"petId": "34"} == request["headers"]
def assert_validate_call_count(expected_call_count, config, petstore_dict):
with patch('bravado_core.param.validate_schema_object') as m_validate:
petstore_spec = Spec.from_dict(petstore_dict, config=config)
request = {'url': '/pet/{petId}'}
op = petstore_spec.resources['pet'].operations['getPetById']
param = op.params['petId']
marshal_param(param, 34, request)
assert expected_call_count == m_validate.call_count
def test_path_string(empty_swagger_spec, param_spec, string_param,
expected_path):
param_spec['in'] = 'path'
param_spec['type'] = 'string'
del param_spec['format']
param = Param(empty_swagger_spec, Mock(spec=Operation), param_spec)
request = {'url': '/pet/{petId}'}
marshal_param(param, string_param, request)
assert expected_path == request['url']
def test_required_param(minimal_swagger_spec, string_param_spec, request_dict):
string_param_spec['required'] = True
value = 'abc'
param = Param(minimal_swagger_spec, Mock(spec=Operation),
string_param_spec)
expected = copy.deepcopy(request_dict)
expected['params']['username'] = value
marshal_param(param, value, request_dict)
assert expected == request_dict
def test_required_param_failure(minimal_swagger_spec, string_param_spec,
request_dict):
string_param_spec['required'] = True
value = None
param = Param(minimal_swagger_spec, Mock(
spec=Operation), string_param_spec)
with pytest.raises(SwaggerMappingError) as excinfo:
marshal_param(param, value, request_dict)
assert 'is a required value' in str(excinfo.value)
def test_required_param(minimal_swagger_spec, string_param_spec, request_dict):
string_param_spec['required'] = True
value = 'abc'
param = Param(minimal_swagger_spec, Mock(
spec=Operation), string_param_spec)
expected = copy.deepcopy(request_dict)
expected['params']['username'] = value
marshal_param(param, value, request_dict)
assert expected == request_dict
def test_formData_integer(empty_swagger_spec, param_spec):
param_spec['in'] = 'formData'
param = Param(empty_swagger_spec, Mock(spec=Operation), param_spec)
request = {
'headers': {
}
}
marshal_param(param, 34, request)
assert 34 == request['data']['petId']
def test_path_unicode_string(empty_swagger_spec, param_spec):
param_spec['in'] = 'path'
param_spec['type'] = 'string'
del param_spec['format']
param = Param(empty_swagger_spec, Mock(spec=Operation), param_spec)
request = {'url': '/pet/{petId}'}
marshal_param(param, u'Ümlaut', request)
# verify no escaping/encoding takes place on URL
assert u'/pet/Ümlaut' == request['url']
def test_path_unicode_string(empty_swagger_spec, param_spec):
param_spec['in'] = 'path'
param_spec['type'] = 'string'
del param_spec['format']
param = Param(empty_swagger_spec, Mock(spec=Operation), param_spec)
request = {'url': '/pet/{petId}'}
marshal_param(param, u'Ümlaut', request)
# verify no escaping/encoding takes place on URL
assert u'/pet/Ümlaut' == request['url']
def test_required_param_failure(minimal_swagger_spec, string_param_spec,
request_dict):
string_param_spec['required'] = True
value = None
param = Param(minimal_swagger_spec, Mock(spec=Operation),
string_param_spec)
with pytest.raises(SwaggerMappingError) as excinfo:
marshal_param(param, value, request_dict)
assert 'is a required value' in str(excinfo.value)
def test_path_unicode_string(empty_swagger_spec, param_spec):
param_spec["in"] = "path"
param_spec["type"] = "string"
del param_spec["format"]
param = Param(empty_swagger_spec, Mock(spec=Operation), param_spec)
request = {"url": "/pet/{petId}"}
marshal_param(param, u"Ümlaut", request)
# verify no escaping/encoding takes place on URL
assert u"/pet/Ümlaut" == request["url"]
def test_optional_query_array_with_no_value(
empty_swagger_spec,
array_param_spec,
request_dict,
):
array_param_spec['required'] = False
param = Param(empty_swagger_spec, Mock(spec=Operation), array_param_spec)
expected = copy.deepcopy(request_dict)
marshal_param(param, value=None, request=request_dict)
assert expected == request_dict
def test_required_query_array_with_no_value(
empty_swagger_spec,
array_param_spec,
request_dict,
):
array_param_spec['required'] = True
param = Param(empty_swagger_spec, Mock(spec=Operation), array_param_spec)
with pytest.raises(ValidationError) as excinfo:
marshal_param(param, value=None, request=request_dict)
assert 'is a required parameter' in str(excinfo.value)
def test_header_integer(empty_swagger_spec, param_spec):
param_spec['in'] = 'header'
param_spec['type'] = 'integer'
del param_spec['format']
param = Param(empty_swagger_spec, Mock(spec=Operation), param_spec)
request = {
'headers': {}
}
marshal_param(param, 34, request)
assert {'petId': '34'} == request['headers']
def test_body(empty_swagger_spec, param_spec):
param_spec['in'] = 'body'
param_spec['schema'] = {'type': 'integer'}
del param_spec['type']
del param_spec['format']
param = Param(empty_swagger_spec, Mock(spec=Operation), param_spec)
request = {'headers': {}}
marshal_param(param, 34, request)
assert '34' == request['data']
assert APP_JSON == request['headers']['Content-Type']
def test_ref(minimal_swagger_dict, array_param_spec, request_dict):
ref_spec = {'$ref': '#/refs/ArrayParam'}
minimal_swagger_dict['refs'] = {'ArrayParam': array_param_spec}
swagger_spec = Spec(minimal_swagger_dict)
param = Param(swagger_spec, Mock(spec=Operation), ref_spec)
value = ['cat', 'dog', 'bird']
expected = copy.deepcopy(request_dict)
expected['params']['animals'] = ','.join(value)
marshal_param(param, value, request_dict)
assert expected == request_dict
def test_ref(minimal_swagger_dict, array_param_spec, request_dict):
ref_spec = {"$ref": "#/refs/ArrayParam"}
minimal_swagger_dict["refs"] = {"ArrayParam": array_param_spec}
swagger_spec = Spec(minimal_swagger_dict)
param = Param(swagger_spec, Mock(spec=Operation), ref_spec)
value = ["cat", "dog", "bird"]
expected = copy.deepcopy(request_dict)
expected["params"]["animals"] = ",".join(value)
marshal_param(param, value, request_dict)
assert expected == request_dict
def test_body(empty_swagger_spec, param_spec):
param_spec['in'] = 'body'
param_spec['schema'] = {'type': 'integer'}
del param_spec['type']
del param_spec['format']
param = Param(empty_swagger_spec, Mock(spec=Operation), param_spec)
request = {'headers': {}}
marshal_param(param, 34, request)
assert '34' == request['data']
assert APP_JSON == request['headers']['Content-Type']
def test_ref(minimal_swagger_dict, array_param_spec, request_dict):
ref_spec = {'$ref': '#/refs/ArrayParam'}
minimal_swagger_dict['refs'] = {'ArrayParam': array_param_spec}
swagger_spec = Spec(minimal_swagger_dict)
param = Param(swagger_spec, Mock(spec=Operation), ref_spec)
value = ['cat', 'dog', 'bird']
expected = copy.deepcopy(request_dict)
expected['params']['animals'] = ','.join(value)
marshal_param(param, value, request_dict)
assert expected == request_dict
def test_body(empty_swagger_spec, param_spec):
param_spec["in"] = "body"
param_spec["schema"] = {"type": "integer"}
del param_spec["type"]
del param_spec["format"]
param = Param(empty_swagger_spec, Mock(spec=Operation), param_spec)
request = {"headers": {}}
marshal_param(param, 34, request)
assert "34" == request["data"]
assert APP_JSON == request["headers"]["Content-Type"]
def test_formData_file(empty_swagger_spec, param_spec, request_dict):
param_spec['in'] = 'formData'
param_spec['type'] = 'file'
param = Param(empty_swagger_spec,
Mock(spec=Operation, consumes=['multipart/form-data']),
param_spec)
marshal_param(param, "i am the contents of a file", request_dict)
expected = {
'params': {},
'files': [('petId', ('petId', "i am the contents of a file"))],
}
assert expected == request_dict
def test_formData_file(empty_swagger_spec, param_spec, request_dict):
param_spec['in'] = 'formData'
param_spec['type'] = 'file'
param = Param(empty_swagger_spec,
Mock(spec=Operation, consumes=['multipart/form-data']),
param_spec)
marshal_param(param, "i am the contents of a file", request_dict)
expected = {
'params': {},
'files': [('petId', ('petId', "i am the contents of a file"))],
}
assert expected == request_dict
def test_boolean_query_params_are_lower_case(
minimal_swagger_dict,
param_required,
param_type,
param_format,
param_python_value,
param_string_value,
):
op_spec = {
'operationId': 'get_pet_by_id',
# op params would go here
'responses': {
'200': {}
}
}
param_spec = {
'name': 'querry-param',
'in': 'query',
'required': param_required,
'type': param_type,
}
if param_format is not None:
param_spec['format'] = param_format
path_spec = {
'get': op_spec,
'parameters': [param_spec],
}
minimal_swagger_dict['paths']['/pets'] = path_spec
swagger_spec = Spec(minimal_swagger_dict)
request_dictionary = {'params': {}}
param = Param(swagger_spec, Mock(spec=Operation), param_spec)
marshal_param(param, param_python_value, request_dictionary)
if param_required or param_python_value is not None:
assert request_dictionary['params'][
param_spec['name']] == param_string_value
else:
assert param_spec['name'] not in request_dictionary['params']
# Checks that the conversion back continues to work
request_object = Mock(spec=IncomingRequest,
query={param_spec['name']: param_string_value})
assert unmarshal_param(param, request_object) == param_python_value
def construct_params(operation, request, op_kwargs):
"""Given the parameters passed to the operation invocation, validates and
marshals the parameters into the provided request dict.
:type operation: :class:`bravado_core.operation.Operation`
:type request: dict
:param op_kwargs: the kwargs passed to the operation invocation
:raises: SwaggerMappingError on extra parameters or when a required
parameter is not supplied.
"""
current_params = operation.params.copy()
for param_name, param_value in iteritems(op_kwargs):
param = current_params.pop(param_name, None)
if param is None:
raise SwaggerMappingError(
"{0} does not have parameter {1}"
.format(operation.operation_id, param_name))
marshal_param(param, param_value, request)
# Check required params and non-required params with a 'default' value
for remaining_param in itervalues(current_params):
if remaining_param.location == 'header' and remaining_param.name in request['headers']:
marshal_param(remaining_param, request['headers'][remaining_param.name], request)
else:
if remaining_param.required:
raise SwaggerMappingError(
'{0} is a required parameter'.format(remaining_param.name))
if not remaining_param.required and remaining_param.has_default():
marshal_param(remaining_param, None, request)
def test_formData_integer(empty_swagger_spec, param_spec):
param_spec["in"] = "formData"
param = Param(empty_swagger_spec, Mock(spec=Operation), param_spec)
request = {"headers": {}}
marshal_param(param, 34, request)
assert 34 == request["data"]["petId"]
def test_query_string(empty_swagger_spec, string_param_spec, request_dict):
param = Param(empty_swagger_spec, Mock(spec=Operation), string_param_spec)
expected = copy.deepcopy(request_dict)
expected["params"]["username"] = "******"
marshal_param(param, "darwin", request_dict)
assert expected == request_dict
def test_query_string(empty_swagger_spec, string_param_spec, request_dict):
param = Param(empty_swagger_spec, Mock(spec=Operation), string_param_spec)
expected = copy.deepcopy(request_dict)
expected['params']['username'] = '******'
marshal_param(param, 'darwin', request_dict)
assert expected == request_dict
def test_query_string(empty_swagger_spec, string_param_spec, request_dict):
param = Param(empty_swagger_spec, Mock(spec=Operation), string_param_spec)
expected = copy.deepcopy(request_dict)
expected['params']['username'] = '******'
marshal_param(param, 'darwin', request_dict)
assert expected == request_dict
def test_formData_integer(empty_swagger_spec, param_spec):
param_spec['in'] = 'formData'
param = Param(empty_swagger_spec, Mock(spec=Operation), param_spec)
request = {'headers': {}}
marshal_param(param, 34, request)
assert 34 == request['data']['petId']
