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_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_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_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_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_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_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_handle_error_called_when_parsing_raises_error(handle_error, web_request):
# handle_error must raise an error to be valid
handle_error.side_effect = ValidationError("parsing failed")
def always_fail(*args, **kwargs):
raise ValidationError("error occurred")
p = Parser()
assert handle_error.call_count == 0
with pytest.raises(ValidationError):
p.parse({"foo": fields.Field()}, web_request, validate=always_fail)
assert handle_error.call_count == 1
with pytest.raises(ValidationError):
p.parse({"foo": fields.Field()}, web_request, validate=always_fail)
assert handle_error.call_count == 2
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)
def test_custom_error_handler_decorator(web_request):
class CustomError(Exception):
pass
mock_schema = mock.Mock(spec=Schema)
mock_schema.strict = True
mock_schema.load.side_effect = ValidationError("parsing json failed")
parser = Parser()
@parser.error_handler
def handle_error(error, req, schema, status_code, headers):
assert isinstance(schema, Schema)
raise CustomError(error)
with pytest.raises(CustomError):
parser.parse(mock_schema, web_request)
def test_custom_error_handler_must_reraise(web_request):
class CustomError(Exception):
pass
mock_schema = mock.Mock(spec=Schema)
mock_schema.strict = True
mock_schema.load.side_effect = ValidationError("parsing json failed")
parser = Parser()
@parser.error_handler
def handle_error(error, req, schema, *, error_status_code, error_headers):
pass
# because the handler above does not raise a new error, the parser should
# raise a ValueError -- indicating a programming error
with pytest.raises(ValueError):
parser.parse(mock_schema, web_request)
def test_parse(parse_json, request):
parse_json.return_value = 42
argmap = {
'username': Arg(),
'password': Arg()
}
p = Parser()
ret = p.parse(argmap, request)
assert {'username': 42, 'password': 42} == ret
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_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)
result = parser.parse({'foo': Arg(int)}, web_request, locations=('data', ))
assert result['foo'] == 42
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_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_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_load_nondefault_called_by_parse_with_location(location, web_request):
with mock.patch("webargs.core.Parser.load_{}".format(
location)) as mock_loadfunc, mock.patch(
"webargs.core.Parser.load_json") as load_json:
mock_loadfunc.return_value = {}
load_json.return_value = {}
p = Parser()
# ensure that without location=..., the loader is not called (json is
# called)
p.parse({"foo": fields.Field()}, web_request)
assert mock_loadfunc.call_count == 0
assert load_json.call_count == 1
# but when location=... is given, the loader *is* called and json is
# not called
p.parse({"foo": fields.Field()}, web_request, location=location)
assert mock_loadfunc.call_count == 1
# it was already 1, should not go up
assert load_json.call_count == 1
def test_custom_error_handler(web_request):
class CustomError(Exception):
pass
def error_handler(error, req, schema, status_code, headers):
assert isinstance(schema, Schema)
raise CustomError(error)
def failing_validate_func(args):
raise ValidationError("parsing failed")
class MySchema(Schema):
foo = fields.Int()
myschema = MySchema(**strict_kwargs)
web_request.json = {"foo": "hello world"}
p = Parser(error_handler=error_handler)
with pytest.raises(CustomError):
p.parse(myschema, web_request, validate=failing_validate_func)
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_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 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_location_handler_with_data_key(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)
data_key_kwarg = {
"load_from" if (MARSHMALLOW_VERSION_INFO[0] < 3) else "data_key": "X-Foo"
}
result = parser.parse(
{"x_foo": fields.Int(**data_key_kwarg)}, web_request, locations=("data",)
)
assert result["x_foo"] == 42
def test_custom_location_loader_with_data_key(web_request):
web_request.data = {"X-Foo": 42}
parser = Parser()
@parser.location_loader("data")
def load_data(req, schema):
return req.data
data_key_kwarg = {
"load_from" if (MARSHMALLOW_VERSION_INFO[0] < 3) else "data_key":
"X-Foo"
}
result = parser.parse({"x_foo": fields.Int(**data_key_kwarg)},
web_request,
location="data")
assert result["x_foo"] == 42
def test_custom_location_handler_with_data_key(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)
data_key_kwarg = {
'load_from' if (MARSHMALLOW_VERSION_INFO[0] < 3) else 'data_key':
'X-Foo'
}
result = parser.parse({'x_foo': fields.Int(**data_key_kwarg)},
web_request,
locations=('data', ))
assert result['x_foo'] == 42
def test_parse_files(parse_files, web_request):
p = Parser()
p.parse({'foo': fields.Field()}, web_request, locations=('files',))
assert parse_files.called
def test_parse_files(parse_files, request):
p = Parser()
p.parse({'foo': Arg()}, request, targets=('files',))
assert parse_files.called
def test_targets_as_init_arguments(parse_headers, request):
p = Parser(targets=('headers',))
p.parse({'foo': Arg()}, request)
assert parse_headers.called
def test_fallback_used_if_all_other_functions_return_none(fallback, request):
arg = Arg()
p = Parser()
p.parse({'foo': arg}, request)
fallback.assert_called
def test_load_json_called_by_parse_default(load_json, web_request):
schema = dict2schema({"foo": fields.Field()})()
load_json.return_value = {"foo": 1}
p = Parser()
p.parse(schema, web_request)
load_json.assert_called_with(web_request, schema)
def test_location_as_init_argument(load_headers, web_request):
p = Parser(location="headers")
load_headers.return_value = {}
p.parse({"foo": fields.Field()}, web_request)
assert load_headers.called
def test_parse_files(parse_files, web_request):
p = Parser()
p.parse({"foo": fields.Field()}, web_request, locations=("files", ))
assert parse_files.called
def test_locations_as_init_arguments(parse_headers, web_request):
p = Parser(locations=('headers',))
p.parse({'foo': fields.Field()}, web_request)
assert parse_headers.called
