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