def type_allowed(val):
if val == settings.DEFAULT_METHOD:
raise ValidationError(
'Default type cannot be explicity chosen. Omit t parameter.',
status_code=422)
if val not in RESIZE_METHODS:
raise ValidationError('Resize type parameter not recognized',
status_code=422)
def correct_arguments(args):
if not args.get('w') and not args.get('h'):
raise ValidationError(
'Must provide at least one length parameter,w or h.',
status_code=422)
if args.get('t'):
if not args.get('w') or not args.get('h'):
raise ValidationError('Must provide both w and h for this method.',
status_code=422)
def verifyMachines(machines):
if isinstance(machines, list):
for machine in machines:
if isinstance(machine, dict) and machine.has_key('Mac'):
return True
else:
raise ValidationError('输入的Machines字符不正确 ！')
else:
raise ValidationError('输入的Machines字符不正确 ！')
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': Arg()}, web_request, locations=('json',))
handle_error.assert_called
parse_json.side_effect = ValidationError('another exception')
p.parse({'foo': Arg()}, web_request, locations=('json',))
assert handle_error.call_count == 2
def _parse_postfile(postfile):
"""
Parse a FDSNWS formatted POST request file.
:param str postfile: Postfile content
:returns: Dictionary with parsed parameters.
:rtype: dict
"""
_StreamEpoch = namedtuple(
"_StreamEpoch", ["net", "sta", "loc", "cha", "start", "end"]
)
retval = {}
stream_epochs = []
for line in postfile.split("\n"):
check_param = line.split(FDSNWS_QUERY_VALUE_SEPARATOR_CHAR, 1)
if len(check_param) == 2:
if (
not all(v.strip() for v in check_param)
or FDSNWS_QUERY_VALUE_SEPARATOR_CHAR in check_param[1]
):
raise ValidationError(f"Illegal POST line: {line!r}")
# add query params
retval[check_param[0].strip()] = check_param[1].strip()
elif len(check_param) == 1:
# ignore empty lines
if not check_param[0].strip():
continue
# parse StreamEpoch
stream_epoch = line.split()
if len(stream_epoch) == 6:
stream_epoch = _StreamEpoch(
net=stream_epoch[0],
sta=stream_epoch[1],
loc=stream_epoch[2],
cha=stream_epoch[3],
start=stream_epoch[4],
end=stream_epoch[5],
)
stream_epochs.append(stream_epoch)
else:
raise ValidationError(f"Illegal POST line: {line!r}")
# remove duplicates
stream_epochs = list(set(stream_epochs))
retval["stream_epochs"] = [se._asdict() for se in stream_epochs]
return retval
def generate_thumbnail(self, content):
content = file_from_content(content)
try:
uploaded_image = Image.open(content)
except Exception:
flask.abort(400, ValidationError(
{
'message': 'File Format',
'object': {"error": "Format Incorrect"},
}
))
if max(uploaded_image.size) >= self.max_size:
uploaded_image.thumbnail((self.max_size, self.max_size), Image.BILINEAR)
content = SpooledTemporaryFile(INMEMORY_FILESIZE)
uploaded_image.save(content, uploaded_image.format)
content.seek(0)
thumbnail = uploaded_image.copy()
thumbnail.thumbnail(self.thumbnail_size, Image.ANTIALIAS)
thumbnail = thumbnail.convert('RGBA')
thumbnail.format = self.thumbnail_format
output = SpooledTemporaryFile(INMEMORY_FILESIZE)
thumbnail.save(output, self.thumbnail_format)
output.seek(0)
thumb_path, thumb_id = self.store_content(output,
'thumb.%s' % self.thumbnail_format.lower())
self['thumb_id'] = thumb_id
self['thumb_path'] = thumb_path
thumbnail_file = self.thumb_file
self['_thumb_public_url'] = thumbnail_file.public_url
content.close()
def _perform_create(self, data, **kwargs):
"""Check for conflicts and create a new object
Is is passed the data parsed by the marshmallow schema (it
transform from raw post data to a JSON)
"""
obj = self.model_class(**data)
# assert not db.session.new
try:
db.session.add(obj)
db.session.commit()
except sqlalchemy.exc.IntegrityError as ex:
if not is_unique_constraint_violation(ex):
raise
db.session.rollback()
conflict_obj = get_conflict_object(db.session, obj, data)
if conflict_obj:
flask.abort(
409,
ValidationError({
'message':
'Existing value',
'object':
self._get_schema_class()().dump(conflict_obj).data,
}))
else:
raise
return obj
def _perform_create(self, data, workspace_name):
assert not db.session.new
workspace = self._get_workspace(workspace_name)
obj = self.model_class(**data)
obj.workspace = workspace
# assert not db.session.new
try:
db.session.add(obj)
db.session.commit()
except sqlalchemy.exc.IntegrityError as ex:
if not is_unique_constraint_violation(ex):
raise
db.session.rollback()
workspace = self._get_workspace(workspace_name)
conflict_obj = get_conflict_object(db.session, obj, data,
workspace)
if conflict_obj:
flask.abort(
409,
ValidationError({
'message':
'Existing value',
'object':
self._get_schema_class()().dump(conflict_obj).data,
}))
else:
raise
self._set_command_id(obj, True)
return obj
def _perform_update(self, object_id, obj, data, workspace_name=None):
"""Commit the SQLAlchemy session, check for updating conflicts"""
try:
db.session.add(obj)
db.session.commit()
except sqlalchemy.exc.IntegrityError as ex:
if not is_unique_constraint_violation(ex):
raise
db.session.rollback()
workspace = None
if workspace_name:
workspace = db.session.query(Workspace).filter_by(
name=workspace_name).first()
conflict_obj = get_conflict_object(db.session, obj, data,
workspace)
if conflict_obj:
flask.abort(
409,
ValidationError({
'message':
'Existing value',
'object':
self._get_schema_class()().dump(conflict_obj).data,
}))
else:
raise
return obj
def page(page):
if has_stephanus_shape(page) == False:
raise ValidationError('Invalid format for Stephanus page')
match = db.pages.find_one({'id': page}, {'_id': 0})
resp = jsonify(match)
resp.status_code = 200
return resp
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, 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': Arg()}, web_request)
def _perform_create(self, data, **kwargs):
obj = self.model_class(**data)
# assert not db.session.new
try:
db.session.add(obj)
db.session.commit()
except sqlalchemy.exc.IntegrityError as ex:
if not is_unique_constraint_violation(ex):
raise
db.session.rollback()
conflict_obj = get_conflict_object(db.session, obj, data)
if conflict_obj:
abort(409, ValidationError(
{
'message': 'Existing value',
'object': self._get_schema_class()().dump(
conflict_obj).data,
}
))
else:
raise
return obj
def username_exists(val):
if AccountUsername.query.filter_by(username=val).first():
raise ValidationError('用户名已注册', status_code=422)
pass
def test_can_store_extra_data(self):
err = ValidationError('foo', headers={'X-Food-Header': 'pizza'})
assert err.data['headers'] == {'X-Food-Header': 'pizza'}
def always_fail(value):
raise ValidationError('something went wrong',
status_code=401,
extra='some data')
def validateUserType(value):
if value >= 0 and value <= 3:
return True
else:
raise ValidationError(
'The userType field is {}, should be 0,1,2,3'.format(value))
def validate2(args):
if args['b'] > args['a']:
raise ValidationError('a must be > b')
def validate1(args):
if args['a'] > args['b']:
raise ValidationError('b must be > a')
def validate_len(val):
if len(val) < 6:
raise ValidationError('Must be greater than 6 characters.')
def validate(value):
raise ValidationError('Something went wrong.')
def test_handle_error_reraises_errors():
p = Parser()
with pytest.raises(ValidationError):
p.handle_error(ValidationError('error raised'))
def has_digit(val):
if not any(ch.isdigit() for ch in val):
raise ValidationError('Must have a digit.')
def test_repr(self):
err = ValidationError('foo', status_code=403)
assert repr(err) == ('ValidationError({0!r}, '
'status_code=403)'.format(unicode('foo')))
def test_str(self):
err = ValidationError('foo', status_code=403)
assert str(err) == 'foo'
def test_can_store_status_code(self):
err = ValidationError('foo', status_code=401)
assert err.status_code == 401
