def test_parse_cookies_called_when_cookies_is_a_target(parse_cookies, request):
arg = Arg()
p = Parser()
p.parse_arg('foo', arg, request)
assert parse_cookies.call_count == 0
p.parse_arg('foo', arg, request, targets=('cookies', ))
assert parse_cookies.called
def test_parse_cookies_called_when_cookies_is_a_location(parse_cookies, web_request):
arg = Arg()
p = Parser()
p.parse_arg('foo', arg, web_request)
assert parse_cookies.call_count == 0
p.parse_arg('foo', arg, web_request, locations=('cookies',))
parse_cookies.assert_called
def test_parse_cookies_called_when_cookies_is_a_location(parse_cookies, web_request):
field = fields.Field()
p = Parser()
p.parse_arg('foo', field, web_request)
assert parse_cookies.call_count == 0
p.parse_arg('foo', field, web_request, locations=('cookies',))
parse_cookies.assert_called()
def test_value_error_raised_if_invalid_target(request):
arg = Arg()
p = Parser()
with pytest.raises(ValueError) as excinfo:
p.parse_arg('foo', arg, request, targets=('invalidtarget', 'headers'))
assert 'Invalid targets arguments: {0}'.format(['invalidtarget'
]) in str(excinfo)
def test_parse_headers_called_when_headers_is_a_location(parse_headers, web_request):
field = fields.Field()
p = Parser()
p.parse_arg("foo", field, web_request)
assert parse_headers.call_count == 0
p.parse_arg("foo", field, web_request, locations=("headers",))
parse_headers.assert_called()
def test_parse_required_arg_raises_validation_error(parse_json, web_request):
arg = Arg(required=True)
p = Parser()
parse_json.return_value = Missing
with pytest.raises(ValidationError) as excinfo:
p.parse_arg('foo', arg, web_request)
assert 'Required parameter "foo" not found.' in str(excinfo)
def test_value_error_raised_if_parse_arg_called_with_invalid_location(web_request):
field = fields.Field()
p = Parser()
with pytest.raises(ValueError) as excinfo:
p.parse_arg("foo", field, web_request, locations=("invalidlocation", "headers"))
assert "Invalid locations arguments: {0}".format(["invalidlocation"]) in str(
excinfo
)
def test_parse_headers_called_when_headers_is_a_target(parse_headers,
web_request):
arg = Arg()
p = Parser()
p.parse_arg('foo', arg, web_request)
assert parse_headers.call_count == 0
p.parse_arg('foo', arg, web_request, targets=('headers', ))
parse_headers.assert_called
def test_parse(parse_json, web_request):
parse_json.return_value = 42
argmap = {
'username': fields.Field(),
'password': fields.Field(),
}
p = Parser()
ret = p.parse(argmap, web_request)
assert {'username': 42, 'password': 42} == ret
def test_handle_error_called_when_parsing_raises_error(parse_json, handle_error, web_request):
val_err = ValidationError('error occurred')
parse_json.side_effect = val_err
p = Parser()
p.parse({'foo': fields.Field()}, web_request, locations=('json',))
handle_error.assert_called
parse_json.side_effect = ValidationError('another exception')
p.parse({'foo': fields.Field()}, web_request, locations=('json',))
assert handle_error.call_count == 2
def test_handle_error_called_when_parsing_raises_error(parse_json,
handle_error, request):
val_err = ValidationError('error occurred')
parse_json.side_effect = val_err
p = Parser()
p.parse({'foo': Arg()}, request, targets=('json', ))
assert handle_error.called
parse_json.side_effect = Exception('generic exception')
p.parse({'foo': Arg()}, request, targets=('json', ))
assert handle_error.call_count == 2
def test_handle_error_reraises_errors(web_request):
p = Parser()
with pytest.raises(ValidationError):
p.handle_error(
ValidationError("error raised"),
web_request,
Schema(),
error_status_code=422,
error_headers={},
)
def test_value_error_raised_if_invalid_location(web_request):
arg = Arg()
p = Parser()
with pytest.raises(ValueError) as excinfo:
p.parse_arg('foo',
arg,
web_request,
locations=('invalidlocation', 'headers'))
assert 'Invalid locations arguments: {0}'.format(['invalidlocation'
]) in str(excinfo)
def test_parse_required_multiple_arg(parse_form, web_request):
parse_form.return_value = []
arg = Arg(multiple=True, required=True)
p = Parser()
with pytest.raises(RequiredArgMissingError):
p.parse_arg('foo', arg, web_request)
parse_form.return_value = None
with pytest.raises(RequiredArgMissingError):
p.parse_arg('foo', arg, web_request)
def test_custom_error_handler(parse_json, web_request):
class CustomError(Exception):
pass
def error_handler(error):
raise CustomError(error)
parse_json.side_effect = ValidationError('parse_json failed')
p = Parser(error_handler=error_handler)
with pytest.raises(CustomError):
p.parse({'foo': fields.Field()}, web_request)
def test_parse_required_multiple_arg(parse_form, request):
parse_form.return_value = []
arg = Arg(multiple=True, required=True)
p = Parser()
with pytest.raises(ValidationError):
p.parse_arg('foo', arg, request)
parse_form.return_value = None
with pytest.raises(ValidationError):
p.parse_arg('foo', arg, request)
def test_custom_location_handler_with_dest(web_request):
web_request.data = {'X-Foo': 42}
parser = Parser()
@parser.location_handler('data')
def parse_data(req, name, arg):
assert name == 'X-Foo'
return req.data.get(name)
result = parser.parse({'X-Foo': Arg(int, dest='x_foo')}, web_request, locations=('data', ))
assert result['x_foo'] == 42
def test_custom_location_handler(web_request):
web_request.data = {"foo": 42}
parser = Parser()
@parser.location_handler("data")
def parse_data(req, name, arg):
return req.data.get(name, missing)
result = parser.parse({"foo": fields.Int()}, web_request, locations=("data",))
assert result["foo"] == 42
def test_custom_location_handler(web_request):
web_request.data = {'foo': 42}
parser = Parser()
@parser.location_handler('data')
def parse_data(req, name, arg):
return req.data.get(name)
result = parser.parse({'foo': Arg(int)}, web_request, locations=('data', ))
assert result['foo'] == 42
def test_custom_error_handler(parse_json, request):
class CustomError(Exception):
pass
def error_handler(error):
raise CustomError(error)
parse_json.side_effect = AttributeError('parse_json failed')
p = Parser(error_handler=error_handler)
with pytest.raises(CustomError):
p.parse({'foo': Arg()}, request)
def test_custom_location_loader(web_request):
web_request.data = {"foo": 42}
parser = Parser()
@parser.location_loader("data")
def load_data(req, schema):
return req.data
result = parser.parse({"foo": fields.Int()}, web_request, location="data")
assert result["foo"] == 42
def test_handle_error_called_when_parsing_raises_error(handle_error,
web_request):
def always_fail(*args, **kwargs):
raise ValidationError("error occurred")
p = Parser()
assert handle_error.call_count == 0
p.parse({"foo": fields.Field()}, web_request, validate=always_fail)
assert handle_error.call_count == 1
p.parse({"foo": fields.Field()}, web_request, validate=always_fail)
assert handle_error.call_count == 2
def test_custom_target_handler(request):
request.data = {'foo': 42}
parser = Parser()
@parser.target_handler('data')
def parse_data(req, name, arg):
return req.data.get(name)
result = parser.parse({'foo': Arg(int)}, request, targets=('data', ))
assert result['foo'] == 42
def test_custom_location_handler_with_load_from(web_request):
web_request.data = {'X-Foo': 42}
parser = Parser()
@parser.location_handler('data')
def parse_data(req, name, arg):
return req.data.get(name, missing)
result = parser.parse({'x_foo': fields.Int(load_from='X-Foo')},
web_request, locations=('data', ))
assert result['x_foo'] == 42
def test_custom_schema_class(load_json, web_request):
class CustomSchema(Schema):
@pre_load
def pre_load(self, data, **kwargs):
data["value"] += " world"
return data
load_json.return_value = {"value": "hello"}
argmap = {"value": fields.Str()}
p = Parser(schema_class=CustomSchema)
ret = p.parse(argmap, web_request)
assert ret == {"value": "hello world"}
def argmap_to_swagger_params(argmap: ArgMap, req=None):
parser = Parser()
schema = parser._get_schema(argmap, req)
params = {}
for name, field in schema.fields.items():
params[name] = {
'description': field.metadata.get('description',
name.capitalize()),
'type': field_to_type(field)
}
return params
def test_custom_error_handler(parse_json, web_request):
class CustomError(Exception):
pass
def error_handler(error, req, schema, status_code, headers):
assert isinstance(schema, Schema)
raise CustomError(error)
parse_json.side_effect = ValidationError("parse_json failed")
p = Parser(error_handler=error_handler)
with pytest.raises(CustomError):
p.parse({"foo": fields.Field()}, web_request)
def test_custom_error_handler_decorator(parse_json, web_request):
class CustomError(Exception):
pass
parse_json.side_effect = ValidationError('parse_json failed')
parser = Parser()
@parser.error_handler
def handle_error(error):
raise CustomError(error)
with pytest.raises(CustomError):
parser.parse({'foo': Arg()}, web_request)
def test_custom_target_handler_with_source(web_request):
web_request.data = {'X-Foo': 42}
parser = Parser()
@parser.target_handler('data')
def parse_data(req, name, arg):
# The source name is passed
assert name == 'X-Foo'
return req.data.get(name)
result = parser.parse({'x_foo': Arg(int, source='X-Foo')},
web_request,
targets=('data', ))
assert result['x_foo'] == 42
def test_custom_error_handler_decorator(parse_json, web_request):
class CustomError(Exception):
pass
parse_json.side_effect = ValidationError("parse_json failed")
parser = Parser()
@parser.error_handler
def handle_error(error, req, schema):
assert isinstance(schema, Schema)
raise CustomError(error)
with pytest.raises(CustomError):
parser.parse({"foo": fields.Field()}, web_request)
