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_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_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_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']