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_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 _deserialize(self, value, attr, data, **kwargs): # deserialize into the OperationType enum instance corresponding to the value try: return MetaTransaction.OperationType(value) except ValueError: raise ValidationError( f"Could not parse attribute {attr}: {value} has to be one of " f"{[operation_type.value for operation_type in MetaTransaction.OperationType]}" )
def validate_card_existent(id): """ Check card existent. :param id: Parent card ID """ card = Card.query.get(id) if not card: raise \ ValidationError('Invalid parent card id.')
def validate_ownership(id): """ Check if user has access to the parent card. :param id: Parent card ID """ card = Card.query.get(id) if card: if not card.owner_id == current_user.id: raise \ ValidationError('You do not have access to use this card.')
def _items_per_page_validator(arg): """ Validator for a pagination items_per_page number. Args: arg (object): The object to validate as an integer greater than or equal to 1 and less or equal to 250. Returns: int: The validated argument. Raises: ValueError: If the integer is smaller than 1 or it can't be cast to an int. """ arg = int(arg) if arg < 1: raise ValidationError("Value must be greater than or equal to 1.") if arg > 250: raise ValidationError("Value must be less than or equal to 250.") return arg
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 __request_id_validator(request_id: str) -> None: # Replay attack detection specs of Salesforce's cache-only service: # https://developer.salesforce.com/docs/atlas.en-us.securityImplGuide.meta/ # securityImplGuide/security_pe_byok_cache_replay.htm trace_enter(inspect.currentframe()) request_id_length = 32 if len(request_id) != request_id_length: err_msg = ('requestId/nonce length must be %s alphanummeric ' 'chars.' % request_id_length) logger.error(err_msg) trace_exit(inspect.currentframe(), err_msg) raise ValidationError(err_msg, status_code=422) result = re.match('^[a-zA-Z0-9]+$', request_id) if not result: err_msg = ('requestId/nonce must consist of alphanummeric chars only.') logger.error(err_msg) trace_exit(inspect.currentframe(), err_msg) raise ValidationError(err_msg, status_code=422)
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): raise CustomError(error) with pytest.raises(CustomError): parser.parse({'foo': fields.Field()}, web_request)
def validate_strong_password(password): """ Validate request parser password. :param password: Input password """ # Validation rules xp = re.compile(r'^(?=.*?\d)(?=.*?[A-Z])(?=.*?[a-z])[\S]{6,}$') # Match password if not xp.match(password): raise ValidationError('Enter a combination of at least 6 numbers,' '(upper and lowercase) letters.')
def _deserialize(self, value, attr, data, **kwargs): if not isinstance(value, (str, bytes)): raise self.make_error("invalid") try: res_list = [] if isinstance(value, bytes): value = value.decode("utf-8") value = value.replace(" ", "") value_list = value.split(self.split_str) if value else [] for v in value_list: res_list.append(self.trans_type(v)) return res_list except Exception as e: raise ValidationError(str(e))
def _validated(self, value): try: if "_" in value: s1 = value.split(":") chrom = s1[0] pos, alleles = s1[1].split("_") pos = int(pos) ref, alt = alleles.split("/") else: chrom, pos, ref, alt = value.split(":") pos = int(pos) except: raise ValidationError("Invalid variant {}, should be of format: CHROM:POS_REF/ALT or CHROM:POS:REF:ALT".format(value)) if chrom.startswith("chr"): raise ValidationError("Variant chromosome should not contain 'chr': " + value) if not all((x in VariantField.alleles for x in ref)): raise ValidationError("Variant {} had invalid alleles".format(value)) if not all((x in VariantField.alleles for x in alt)): raise ValidationError("Variant {} had invalid alleles".format(value)) return value
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 deserialize_query_filter(value, value_type): value = value.strip() if len(value) == 0: raise ValidationError('empty value') if len(value) > 1 and ((value[0] == '"' and value[-1] == '"') or (value[0] == '\'' and value[-1] == '\'')): operator = '$eq' value = value[1:-1] return {operator: value} elements = value.split(':') if len(elements) == 1: operator = '$eq' value = elements[0] elif len(elements) == 2: operator = '${}'.format(elements[0].lower()) value = elements[1] if operator not in ['$eq', '$ne', '$gt', '$lt', '$gte', '$lte']: raise ValidationError('unknown operator') else: raise ValidationError('too many values') try: if value_type == int: value = int(value) elif value_type == long: value = long(value) elif value_type == float: value = float(value) elif value_type == str: if len(value) > 1 and ((value[0] == '"' and value[-1] == '"') or (value[0] == '\'' and value[-1] == '\'')): value = value[1:-1] else: raise ValidationError('unsupported value type') except: raise ValidationError('invalid value type') return {operator: value}
def test_abort_has_serializable_data(): with pytest.raises(HTTPException) as excinfo: abort(400, message='custom error message') serialized_error = json.dumps(excinfo.value.data) error = json.loads(serialized_error) assert isinstance(error, dict) assert error['message'] == 'custom error message' with pytest.raises(HTTPException) as excinfo: abort(400, message='custom error message', exc=ValidationError('custom error message')) serialized_error = json.dumps(excinfo.value.data) error = json.loads(serialized_error) assert isinstance(error, dict) assert error['message'] == 'custom error message'
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_abort_has_serializable_data(): with pytest.raises(SanicException) as excinfo: abort(400, message="custom error message") serialized_error = json.dumps(excinfo.value.data) error = json.loads(serialized_error) assert isinstance(error, dict) assert error["message"] == "custom error message" with pytest.raises(SanicException) as excinfo: abort( 400, message="custom error message", exc=ValidationError("custom error message"), ) serialized_error = json.dumps(excinfo.value.data) error = json.loads(serialized_error) assert isinstance(error, dict) assert error["message"] == "custom error message"
def test_abort_has_serializable_data(): try: abort(400, message="custom error message") except HandleValidationError as err: serialized_error = json.dumps(err.data) error = json.loads(serialized_error) assert isinstance(error, dict) assert error["message"] == "custom error message" try: abort( 400, message="custom error message", exc=ValidationError("custom error message"), ) except HandleValidationError as excinfo: serialized_error = json.dumps(excinfo.data) error = json.loads(serialized_error) assert isinstance(error, dict) assert error["message"] == "custom error message"
def always_fail(val): raise ValidationError('something went wrong', status_code=401, extra='woops')
def must_exist_in_db(val): if val != 1: raise ValidationError("id not exist")
def is_a_valid_object_id(val): try: ObjectId(val) except InvalidId as exc: raise ValidationError(str(exc), status_code=400)
def always_fail(value): raise ValidationError("something went wrong", status_code=400)
def always_fail(value): raise ValidationError("something went wrong")
def radius_gte_zero(val): if val < 0: raise ValidationError("radius must greater than equal 0")
def __call__(self, value): if value.lstrip('-') not in self.values: raise ValidationError('Cannot sort on value "{0}"'.format(value), status_code=422)
def _validate_natural(value): if value < 0: raise ValidationError('Must be a natural number')
def validate_category_id(val): cid = Category.query.get(val) if not cid: raise ValidationError("分类不存在")
def _deserialize(self, value, attr, data, **kwargs): if not is_address(value): raise ValidationError( f"Could not parse attribute {attr}: Invalid address {value}") return to_checksum_address(value)