def test_allow_unknown_with_oneof_rules(validator): # https://github.com/pyeve/cerberus/issues/251 schema = { 'test': { 'oneof': [ { 'type': 'dict', 'allow_unknown': True, 'schema': {'known': {'type': 'string'}} }, { 'type': 'dict', 'schema': {'known': {'type': 'string'}} }, ] } } # check regression and that allow unknown does not cause any different # than expected behaviour for one-of. document = {'test': {'known': 's'}} validator(document, schema) _errors = validator._errors assert len(_errors) == 1 assert_has_error(_errors, 'test', ('test', 'oneof'), errors.ONEOF, schema['test']['oneof']) assert len(_errors[0].child_errors) == 0 # check that allow_unknown is actually applied document = {'test': {'known': 's', 'unknown': 'asd'}} assert_success(document, validator=validator)
def test_noneof(): # prop1 can not be: # - greater than 10 # - greater than 0 # - equal to -5, 5, or 15 schema = {"prop1": {"type": "integer", "noneof": [{"min": 0}, {"min": 10}, {"allowed": [-5, 5, 15]}]}} # document is valid doc = {"prop1": -1} assert_success(doc, schema) # document is not valid # prop1 is equal to -5 doc = {"prop1": -5} assert_fail(doc, schema) # document is not valid # prop1 greater than 0 doc = {"prop1": 1} assert_fail(doc, schema) # document is not valid doc = {"prop1": 5} assert_fail(doc, schema) # document is not valid doc = {"prop1": 11} assert_fail(doc, schema) # document is not valid # and equal to 15 doc = {"prop1": 15} assert_fail(doc, schema)
def test_dependencies_on_boolean_field_with_value_in_list(): # https://github.com/nicolaiarocci/cerberus/issues/138 schema = {"deleted": {"type": "boolean"}, "text": {"dependencies": {"deleted": [False]}}} assert_success({"text": "foo", "deleted": False}, schema) assert_fail({"text": "foo", "deleted": True}, schema) assert_fail({"text": "foo"}, schema)
def test_nested_readonly_field_with_default_value(): schema = { "some_field": { "type": "dict", "schema": { "created": {"type": "string", "readonly": True, "default": "today"}, "modified": {"type": "string", "readonly": True, "default_setter": lambda d: d["created"]}, }, } } assert_success({"some_field": {}}, schema) expected_errors = [ ( ("some_field", "created"), ("some_field", "schema", "created", "readonly"), errors.READONLY_FIELD, schema["some_field"]["schema"]["created"]["readonly"], ), ( ("some_field", "modified"), ("some_field", "schema", "modified", "readonly"), errors.READONLY_FIELD, schema["some_field"]["schema"]["modified"]["readonly"], ), ] assert_fail({"some_field": {"created": "tomorrow", "modified": "now"}}, schema, errors=expected_errors) assert_fail({"some_field": {"created": "today", "modified": "today"}}, schema, errors=expected_errors)
def test_a_dict_with_valueschema(validator): assert_success({"a_dict_with_valueschema": {"an integer": 99, "another integer": 100}}) error = ( "a_dict_with_valueschema", ("a_dict_with_valueschema", "valueschema"), errors.VALUESCHEMA, {"type": "integer"}, ) child_errors = [ ( ("a_dict_with_valueschema", "a string"), ("a_dict_with_valueschema", "valueschema", "type"), errors.BAD_TYPE, "integer", ) ] assert_fail( {"a_dict_with_valueschema": {"a string": "99"}}, validator=validator, error=error, child_errors=child_errors ) assert "valueschema" in validator.schema_error_tree["a_dict_with_valueschema"] v = validator.schema_error_tree assert len(v["a_dict_with_valueschema"]["valueschema"].descendants) == 1
def test_dependencies_dict_with_required_field(): schema = { 'test_field': { 'required': True, 'dependencies': {'foo': 'foo', 'bar': 'bar'} }, 'foo': {'type': 'string'}, 'bar': {'type': 'string'} } # False: all dependencies missing assert_fail({'test_field': 'foobar'}, schema) # False: one of dependencies missing assert_fail({'test_field': 'foobar', 'foo': 'foo'}, schema) assert_fail({'test_field': 'foobar', 'bar': 'bar'}, schema) # False: dependencies are validated and field is required assert_fail({'foo': 'foo', 'bar': 'bar'}, schema) # False: All dependencies are optional, but field is still required assert_fail({}, schema) # False: dependency missing assert_fail({'foo': 'bar'}, schema) assert_success({'test_field': 'foobar', 'foo': 'foo', 'bar': 'bar'}, schema) # True: dependencies are validated but field is not required schema['test_field']['required'] = False assert_success({'foo': 'bar', 'bar': 'foo'}, schema)
def test_ignore_none_values(): field = 'test' schema = {field: {'type': 'string', 'empty': False, 'required': False}} document = {field: None} # Test normal behaviour validator = Validator(schema, ignore_none_values=False) assert_fail(document, validator=validator) validator.schema[field]['required'] = True validator.schema.validate() _errors = assert_fail(document, validator=validator) assert_not_has_error(_errors, field, (field, 'required'), errors.REQUIRED_FIELD, True) # Test ignore None behaviour validator = Validator(schema, ignore_none_values=True) validator.schema[field]['required'] = False validator.schema.validate() assert_success(document, validator=validator) validator.schema[field]['required'] = True _errors = assert_fail(schema=schema, document=document, validator=validator) assert_has_error(_errors, field, (field, 'required'), errors.REQUIRED_FIELD, True) assert_not_has_error(_errors, field, (field, 'type'), errors.BAD_TYPE, 'string')
def test_self_root_document(): """ Make sure self.root_document is always the root document. See: * https://github.com/pyeve/cerberus/pull/42 * https://github.com/pyeve/eve/issues/295 """ class MyValidator(Validator): def _validate_root_doc(self, root_doc, field, value): """ {'type': 'boolean'} """ if ('sub' not in self.root_document or len(self.root_document['sub']) != 2): self._error(field, 'self.context is not the root doc!') schema = { 'sub': { 'type': 'list', 'root_doc': True, 'schema': { 'type': 'dict', 'schema': { 'foo': { 'type': 'string', 'root_doc': True } } } } } assert_success({'sub': [{'foo': 'bar'}, {'foo': 'baz'}]}, validator=MyValidator(schema))
def test_nested_unknown_keys(): schema = {"field1": {"type": "dict", "allow_unknown": True, "schema": {"nested1": {"type": "string"}}}} document = {"field1": {"nested1": "foo", "arb1": "bar", "arb2": 42}} assert_success(document=document, schema=schema) schema["field1"]["allow_unknown"] = {"type": "string"} assert_fail(document=document, schema=schema)
def test_nested_readonly_field_with_default_value(): schema = { 'some_field': { 'type': 'dict', 'schema': { 'created': { 'type': 'string', 'readonly': True, 'default': 'today' }, 'modified': { 'type': 'string', 'readonly': True, 'default_setter': lambda d: d['created'] } } } } assert_success({'some_field': {}}, schema) expected_errors = [ (('some_field', 'created'), ('some_field', 'schema', 'created', 'readonly'), errors.READONLY_FIELD, schema['some_field']['schema']['created']['readonly']), (('some_field', 'modified'), ('some_field', 'schema', 'modified', 'readonly'), errors.READONLY_FIELD, schema['some_field']['schema']['modified']['readonly'])] assert_fail({'some_field': {'created': 'tomorrow', 'modified': 'now'}}, schema, errors=expected_errors) assert_fail({'some_field': {'created': 'today', 'modified': 'today'}}, schema, errors=expected_errors)
def test_unknown_keys_list_of_dicts(validator): # test that allow_unknown is honored even for subdicts in lists. # https://github.com/pyeve/cerberus/issues/67. validator.allow_unknown = True document = {'a_list_of_dicts': [{'sku': 'YZ069', 'price': 25, 'extra': True}]} assert_success(document, validator=validator)
def test_allow_unknown_with_of_rules(): # https://github.com/pyeve/cerberus/issues/251 schema = { 'test': { 'oneof': [ { 'type': 'dict', 'allow_unknown': True, 'schema': {'known': {'type': 'string'}}, }, {'type': 'dict', 'schema': {'known': {'type': 'string'}}}, ] } } # check regression and that allow unknown does not cause any different # than expected behaviour for one-of. document = {'test': {'known': 's'}} assert_fail( document, schema, error=('test', ('test', 'oneof'), errors.ONEOF, schema['test']['oneof']), ) # check that allow_unknown is actually applied document = {'test': {'known': 's', 'unknown': 'asd'}} assert_success(document, schema)
def test_dependencies_on_boolean_field_with_value_in_list(): # https://github.com/pyeve/cerberus/issues/138 schema = {'deleted': {'type': 'boolean'}, 'text': {'dependencies': {'deleted': [False]}}} assert_success({'text': 'foo', 'deleted': False}, schema) assert_fail({'text': 'foo', 'deleted': True}, schema) assert_fail({'text': 'foo'}, schema)
def test_regex(validator): field = "a_regex_email" assert_success({field: "*****@*****.**"}, validator=validator) assert_fail( {field: "invalid"}, update=True, error=(field, (field, "regex"), errors.REGEX_MISMATCH, "^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"), )
def test_dependencies_list_with_subodcuments_fields(): schema = { "test_field": {"dependencies": ["a_dict.foo", "a_dict.bar"]}, "a_dict": {"type": "dict", "schema": {"foo": {"type": "string"}, "bar": {"type": "string"}}}, } assert_success({"test_field": "foobar", "a_dict": {"foo": "foo", "bar": "bar"}}, schema) assert_fail({"test_field": "foobar", "a_dict": {}}, schema) assert_fail({"test_field": "foobar", "a_dict": {"foo": "foo"}}, schema)
def test_normalization_with_rules_set(): # https://github.com/pyeve/cerberus/issues/283 rules_set_registry.add('foo', {'default': 42}) assert_normalized({}, {'bar': 42}, {'bar': 'foo'}) rules_set_registry.add('foo', {'default_setter': lambda _: 42}) assert_normalized({}, {'bar': 42}, {'bar': 'foo'}) rules_set_registry.add('foo', {'type': 'integer', 'nullable': True}) assert_success({'bar': None}, {'bar': 'foo'})
def test_unicode_allowed_py3(): """ All strings are unicode in Python 3.x. Input doc and schema have equal strings and validation yield success.""" # issue 280 doc = {'letters': u'♄εℓł☺'} schema = {'letters': {'type': 'string', 'allowed': ['♄εℓł☺']}} assert_success(doc, schema)
def test_issue_107(validator): schema = {"info": {"type": "dict", "schema": {"name": {"type": "string", "required": True}}}} document = {"info": {"name": "my name"}} assert_success(document, schema, validator=validator) v = Validator(schema) assert_success(document, schema, v) # it once was observed that this behaves other than the previous line assert v.validate(document)
def test_dependencies_list(): schema = { 'test_field': {'dependencies': ['foo', 'bar']}, 'foo': {'type': 'string'}, 'bar': {'type': 'string'} } assert_success({'test_field': 'foobar', 'foo': 'bar', 'bar': 'foo'}, schema) assert_fail({'test_field': 'foobar', 'foo': 'bar'}, schema)
def test_required_excludes(): schema = { "this_field": {"type": "dict", "excludes": "that_field", "required": True}, "that_field": {"type": "dict", "excludes": "this_field", "required": True}, } assert_success({"this_field": {}}, schema, update=False) assert_success({"that_field": {}}, schema, update=False) assert_fail({}, schema) assert_fail({"that_field": {}, "this_field": {}}, schema)
def test_a_dict(): assert_success({'a_dict': {'address': 'i live here', 'city': 'in my own town'}}) assert_fail({'a_dict': {'address': 8545}}, errors=[ (('a_dict', 'address'), ('a_dict', 'schema', 'address', 'type'), errors.BAD_TYPE, 'string'), (('a_dict', 'city'), ('a_dict', 'schema', 'city', 'required'), errors.REQUIRED_FIELD, True) ])
def test_a_dict(): assert_success({"a_dict": {"address": "i live here", "city": "in my own town"}}) assert_fail( {"a_dict": {"address": 8545}}, errors=[ (("a_dict", "address"), ("a_dict", "schema", "address", "type"), errors.BAD_TYPE, "string"), (("a_dict", "city"), ("a_dict", "schema", "city", "required"), errors.REQUIRED_FIELD, True), ], )
def test_a_list_of_dicts(): assert_success( { 'a_list_of_dicts': [ {'sku': 'AK345', 'price': 100}, {'sku': 'YZ069', 'price': 25} ] } )
def test_oneof_schema(): schema = {'oneof_schema': {'type': 'dict', 'oneof_schema': [{'digits': {'type': 'integer', 'min': 0, 'max': 99}}, {'text': {'type': 'string', 'regex': '^[0-9]{2}$'}}]}} assert_success({'oneof_schema': {'digits': 19}}, schema) assert_success({'oneof_schema': {'text': '84'}}, schema) assert_fail({'oneof_schema': {'digits': 19, 'text': '84'}}, schema)
def test_root_relative_dependencies(): # https://github.com/pyeve/cerberus/issues/288 schema = {'package': {'allow_unknown': True, 'schema': {'version': {'dependencies': '^repo'}}}, 'repo': {}} assert_fail({'package': {'repo': 'somewhere', 'version': 0}}, schema, error=(('package', 'version'), ('package', 'schema', 'version', 'dependencies'), errors.DEPENDENCIES_FIELD, '^repo', ('^repo',))) assert_success({'repo': 'somewhere', 'package': {'version': 1}}, schema)
def test_issue_107(validator): schema = {'info': {'type': 'dict', 'schema': {'name': {'type': 'string', 'required': True}}}} document = {'info': {'name': 'my name'}} assert_success(document, schema, validator=validator) v = Validator(schema) assert_success(document, schema, v) # it once was observed that this behaves other than the previous line assert v.validate(document)
def test_required_excludes(): schema = {'this_field': {'type': 'dict', 'excludes': 'that_field', 'required': True}, 'that_field': {'type': 'dict', 'excludes': 'this_field', 'required': True}} assert_success({'this_field': {}}, schema, update=False) assert_success({'that_field': {}}, schema, update=False) assert_fail({}, schema) assert_fail({'that_field': {}, 'this_field': {}}, schema)
def test_unknown_keys_retain_custom_rules(): # test that allow_unknown schema respect custom validation rules. # https://github.com/nicolaiarocci/cerberus/issues/#66. class CustomValidator(Validator): def _validate_type_foo(self, value): if value == "foo": return True validator = CustomValidator({}) validator.allow_unknown = {"type": "foo"} assert_success(document={"fred": "foo", "barney": "foo"}, validator=validator)
def test_issue_265(): class MyValidator(Validator): def _validator_oddity(self, field, value): if not value & 1: self._error(field, "Must be an odd number") v = MyValidator(schema={'amount': {'validator': 'oddity'}}) assert_success(document={'amount': 1}, validator=v) assert_fail(document={'amount': 2}, validator=v, error=('amount', (), errors.CUSTOM, None, ('Must be an odd number',)))
def test_anyof_schema(validator): # test that a list of schemas can be specified. valid_parts = [{'schema': {'model number': {'type': 'string'}, 'count': {'type': 'integer'}}}, {'schema': {'serial number': {'type': 'string'}, 'count': {'type': 'integer'}}}] valid_item = {'type': ['dict', 'string'], 'anyof': valid_parts} schema = {'parts': {'type': 'list', 'schema': valid_item}} document = {'parts': [{'model number': 'MX-009', 'count': 100}, {'serial number': '898-001'}, 'misc']} # document is valid. each entry in 'parts' matches a type or schema assert_success(document, schema, validator=validator) document['parts'].append({'product name': "Monitors", 'count': 18}) # document is invalid. 'product name' does not match any valid schemas assert_fail(document, schema, validator=validator) document['parts'].pop() # document is valid again assert_success(document, schema, validator=validator) document['parts'].append({'product name': "Monitors", 'count': 18}) document['parts'].append(10) # and invalid. numbers are not allowed. exp_child_errors = [ (('parts', 3), ('parts', 'schema', 'anyof'), errors.ANYOF, valid_parts), (('parts', 4), ('parts', 'schema', 'type'), errors.BAD_TYPE, ['dict', 'string']) ] _errors = assert_fail(document, schema, validator=validator, error=('parts', ('parts', 'schema'), errors.SEQUENCE_SCHEMA, valid_item), child_errors=exp_child_errors) assert_not_has_error(_errors, ('parts', 4), ('parts', 'schema', 'anyof'), errors.ANYOF, valid_parts) v_errors = validator.errors assert 'parts' in v_errors assert 3 in v_errors['parts'][-1] assert 'anyof' in v_errors['parts'][-1][3][-1] assert v_errors['parts'][-1][3][-1]['anyof'][0] == "no definitions validate" scope = v_errors['parts'][-1][3][-1]['anyof'][-1] assert 'anyof definition 0' in scope assert 'anyof definition 1' in scope assert scope['anyof definition 0'] == ["unknown field"] assert scope['anyof definition 1'] == ["unknown field"] assert v_errors['parts'][-1][4] == ["must be of ['dict', 'string'] type"]
def test_nested_unknown_keys(): schema = { 'field1': { 'type': 'dict', 'allow_unknown': True, 'schema': {'nested1': {'type': 'string'}} } } document = { 'field1': { 'nested1': 'foo', 'arb1': 'bar', 'arb2': 42 } } assert_success(document=document, schema=schema) schema['field1']['allow_unknown'] = {'type': 'string'} assert_fail(document=document, schema=schema)
def test_a_dict_with_valueschema(validator): assert_success({'a_dict_with_valueschema': {'an integer': 99, 'another integer': 100}}) error = ( 'a_dict_with_valueschema', ('a_dict_with_valueschema', 'valueschema'), errors.VALUESCHEMA, {'type': 'integer'}) child_errors = [ (('a_dict_with_valueschema', 'a string'), ('a_dict_with_valueschema', 'valueschema', 'type'), errors.BAD_TYPE, 'integer')] assert_fail({'a_dict_with_valueschema': {'a string': '99'}}, validator=validator, error=error, child_errors=child_errors) assert 'valueschema' in \ validator.schema_error_tree['a_dict_with_valueschema'] v = validator.schema_error_tree assert len(v['a_dict_with_valueschema']['valueschema'].descendants) == 1
def test_allof(): # prop1 has to be a float between 0 and 10 schema = {'prop1': {'allof': [ {'type': 'float'}, {'min': 0}, {'max': 10}]}} doc = {'prop1': -1} assert_fail(doc, schema) doc = {'prop1': 5} assert_success(doc, schema) doc = {'prop1': 11} assert_fail(doc, schema) # prop1 has to be a float and an integer schema = {'prop1': {'allof': [{'type': 'float'}, {'type': 'integer'}]}} doc = {'prop1': 11} assert_success(doc, schema) doc = {'prop1': 11.5} assert_fail(doc, schema) doc = {'prop1': '11'} assert_fail(doc, schema)
def test_one_of_two_types(validator): field = 'one_or_more_strings' assert_success({field: 'foo'}) assert_success({field: ['foo', 'bar']}) exp_child_errors = [ ((field, 1), (field, 'itemsrules', 'type'), errors.TYPE, ('string',)) ] assert_fail( {field: ['foo', 23]}, validator=validator, error=(field, (field, 'itemsrules'), errors.ITEMSRULES, {'type': ('string',)}), child_errors=exp_child_errors, ) assert_fail( {field: 23}, error=((field,), (field, 'type'), errors.TYPE, ('string', 'list')) ) assert validator.errors == { field: [{1: ["must be one of these types: ('string',)"]}] }
def test_issue_107(validator): # https://github.com/pyeve/cerberus/issues/107 schema = { 'info': { 'type': 'dict', 'schema': { 'name': { 'type': 'string', 'required': True } }, } } document = {'info': {'name': 'my name'}} assert_success(document, schema, validator=validator) v = Validator(schema) assert_success(document, schema, v) # it once was observed that this behaves other than the previous line assert v.validate(document)
def test_dependencies_list_with_required_field(): schema = { 'test_field': {'required': True, 'dependencies': ['foo', 'bar']}, 'foo': {'type': 'string'}, 'bar': {'type': 'string'} } # False: all dependencies missing assert_fail({'test_field': 'foobar'}, schema) # False: one of dependencies missing assert_fail({'test_field': 'foobar', 'foo': 'bar'}, schema) # False: one of dependencies missing assert_fail({'test_field': 'foobar', 'bar': 'foo'}, schema) # False: dependencies are validated and field is required assert_fail({'foo': 'bar', 'bar': 'foo'}, schema) # False: All dependencies are optional but field is still required assert_fail({}, schema) # True: dependency missing assert_fail({'foo': 'bar'}, schema) # True: dependencies are validated but field is not required schema['test_field']['required'] = False assert_success({'foo': 'bar', 'bar': 'foo'}, schema)
def test_contextual_data_preservation(): class InheritedValidator(cerberus.Validator): def __init__(self, *args, **kwargs): if 'working_dir' in kwargs: self.working_dir = kwargs['working_dir'] super(InheritedValidator, self).__init__(*args, **kwargs) def _validate_type_test(self, value): if self.working_dir: return True assert 'test' in InheritedValidator.types v = InheritedValidator( {'test': { 'type': 'list', 'schema': { 'type': 'test' } }}, working_dir='/tmp') assert_success({'test': ['foo']}, validator=v)
def test_dependencies_relative_to_document_root(): # https://github.com/pyeve/cerberus/issues/288 subschema = {'version': {'dependencies': ('^repo',)}} schema = {'package': {'allow_unknown': True, 'schema': subschema}, 'repo': {}} assert_success({'repo': 'somewhere', 'package': {'version': 1}}, schema) assert_fail( {'package': {'repo': 'somewhere', 'version': 0}}, schema, error=('package', ('package', 'schema'), errors.SCHEMA, subschema), child_errors=[ ( ('package', 'version'), ('package', 'schema', 'version', 'dependencies'), errors.DEPENDENCIES_FIELD, ('^repo',), ('^repo',), ) ], )
def test_nullable_field(): assert_success({'a_nullable_integer': None}) assert_success({'a_nullable_integer': 3}) assert_success({'a_nullable_field_without_type': None}) assert_fail({'a_nullable_integer': "foo"}) assert_fail({'an_integer': None}) assert_fail({'a_not_nullable_field_without_type': None})
def test_contextual_data_preservation(): class InheritedValidator(cerberus.Validator): def __init__(self, *args, **kwargs): if 'working_dir' in kwargs: self.working_dir = kwargs['working_dir'] super().__init__(*args, **kwargs) def _check_with_test(self, field, value): if self.working_dir: return True assert 'test' in InheritedValidator.checkers v = InheritedValidator( {'test': { 'type': 'list', 'itemsrules': { 'check_with': 'test' } }}, working_dir='/tmp', ) assert_success({'test': ['foo']}, validator=v)
def test_271_normalising_tuples(): # https://github.com/pyeve/cerberus/issues/271 schema = { 'my_field': { 'type': 'list', 'schema': { 'type': ('string', 'number', 'dict') } } } document = { 'my_field': ('foo', 'bar', 42, 'albert', 'kandinsky', { 'items': 23 }) } assert_success(document, schema) normalized = Validator(schema).normalized(document) assert normalized['my_field'] == ('foo', 'bar', 42, 'albert', 'kandinsky', { 'items': 23 })
def test_excludes(): schema = {'this_field': {'type': 'dict', 'excludes': 'that_field'}, 'that_field': {'type': 'dict'}} assert_success({'this_field': {}}, schema) assert_success({'that_field': {}}, schema) assert_success({}, schema) assert_fail({'that_field': {}, 'this_field': {}}, schema)
def test_require_all_and_exclude(): schema = { 'foo': {'type': 'string', 'excludes': 'bar'}, 'bar': {'type': 'string', 'excludes': 'foo'}, } validator = Validator(require_all=True) assert_fail( {}, schema, validator, errors=[ ('foo', '__require_all__', errors.REQUIRED_FIELD, True), ('bar', '__require_all__', errors.REQUIRED_FIELD, True), ], ) assert_success({'foo': 'value'}, schema, validator) assert_success({'bar': 'value'}, schema, validator) assert_fail({'foo': 'value', 'bar': 'value'}, schema, validator) validator.require_all = False assert_success({}, schema, validator) assert_success({'foo': 'value'}, schema, validator) assert_success({'bar': 'value'}, schema, validator) assert_fail({'foo': 'value', 'bar': 'value'}, schema, validator)
def test_dependencies_dict_with_subodcuments_fields(): schema = { 'test_field': {'dependencies': {'a_dict.foo': ['foo', 'bar'], 'a_dict.bar': 'bar'}}, 'a_dict': { 'type': 'dict', 'schema': { 'foo': {'type': 'string'}, 'bar': {'type': 'string'} } } } assert_success({'test_field': 'foobar', 'a_dict': {'foo': 'foo', 'bar': 'bar'}}, schema) assert_success({'test_field': 'foobar', 'a_dict': {'foo': 'bar', 'bar': 'bar'}}, schema) assert_fail({'test_field': 'foobar', 'a_dict': {}}, schema) assert_fail({'test_field': 'foobar', 'a_dict': {'foo': 'foo', 'bar': 'foo'}}, schema) assert_fail({'test_field': 'foobar', 'a_dict': {'bar': 'foo'}}, schema) assert_fail({'test_field': 'foobar', 'a_dict': {'bar': 'bar'}}, schema)
def test_noneof(): # prop1 can not be: # - greater than 10 # - greater than 0 # - equal to -5, 5, or 15 schema = {'prop1': {'type': 'integer', 'noneof': [ {'min': 0}, {'min': 10}, {'allowed': [-5, 5, 15]}]}} # document is valid doc = {'prop1': -1} assert_success(doc, schema) # document is not valid # prop1 is equal to -5 doc = {'prop1': -5} assert_fail(doc, schema) # document is not valid # prop1 greater than 0 doc = {'prop1': 1} assert_fail(doc, schema) # document is not valid doc = {'prop1': 5} assert_fail(doc, schema) # document is not valid doc = {'prop1': 11} assert_fail(doc, schema) # document is not valid # and equal to 15 doc = {'prop1': 15} assert_fail(doc, schema)
def test_allow_unknown_with_of_rules(): # https://github.com/pyeve/cerberus/issues/251 schema = { 'test': { 'oneof': [ { 'type': 'dict', 'allow_unknown': True, 'schema': { 'known': { 'type': 'string' } }, }, { 'type': 'dict', 'schema': { 'known': { 'type': 'string' } } }, ] } } # check regression and that allow unknown does not cause any different # than expected behaviour for one-of. document = {'test': {'known': 's'}} assert_fail( document, schema, error=('test', ('test', 'oneof'), errors.ONEOF, schema['test']['oneof']), ) # check that allow_unknown is actually applied document = {'test': {'known': 's', 'unknown': 'asd'}} assert_success(document, schema)
def test_check_with_rule(validator): def check_with_name(field, value, error): if not value.islower(): error(field, 'must be lowercase') validator.schema = { 'name': { 'check_with': check_with_name }, 'age': { 'type': 'integer' }, } assert_fail( { 'name': 'ItsMe', 'age': 2 }, validator=validator, error=('name', (), errors.CUSTOM, None, ('must be lowercase', )), ) assert validator.errors == {'name': ['must be lowercase']} assert_success({'name': 'itsme', 'age': 2}, validator=validator)
def test_readonly_field_with_default_value(): schema = { 'created': { 'type': 'string', 'readonly': True, 'default': 'today' }, 'modified': { 'type': 'string', 'readonly': True, 'default_setter': lambda d: d['created'] } } assert_success({}, schema) expected_errors = [('created', ('created', 'readonly'), errors.READONLY_FIELD, schema['created']['readonly']), ('modified', ('modified', 'readonly'), errors.READONLY_FIELD, schema['modified']['readonly'])] assert_fail({'created': 'tomorrow', 'modified': 'today'}, schema, errors=expected_errors) assert_fail({'created': 'today', 'modified': 'today'}, schema, errors=expected_errors)
def test_anyof(): # prop1 must be either a number between 0 and 10 schema = {'prop1': {'min': 0, 'max': 10}} doc = {'prop1': 5} assert_success(doc, schema) # prop1 must be either a number between 0 and 10 or 100 and 110 schema = {'prop1': {'anyof': [{'min': 0, 'max': 10}, {'min': 100, 'max': 110}]}} doc = {'prop1': 105} assert_success(doc, schema) # prop1 must be either a number between 0 and 10 or 100 and 110 schema = {'prop1': {'anyof': [{'min': 0, 'max': 10}, {'min': 100, 'max': 110}]}} doc = {'prop1': 50} assert_fail(doc, schema) # prop1 must be an integer that is either be # greater than or equal to 0, or greater than or equal to 10 schema = {'prop1': {'type': 'integer', 'anyof': [{'min': 0}, {'min': 10}]}} assert_success({'prop1': 10}, schema) # test that intermediate schemas do not sustain assert 'type' not in schema['prop1']['anyof'][0] assert 'type' not in schema['prop1']['anyof'][1] assert 'allow_unknown' not in schema['prop1']['anyof'][0] assert 'allow_unknown' not in schema['prop1']['anyof'][1] assert_success({'prop1': 5}, schema) exp_child_errors = [ (('prop1',), ('prop1', 'anyof', 0, 'min'), errors.MIN_VALUE, 0), (('prop1',), ('prop1', 'anyof', 1, 'min'), errors.MIN_VALUE, 10) ] assert_fail({'prop1': -1}, schema, error=(('prop1',), ('prop1', 'anyof'), errors.ANYOF, [{'min': 0}, {'min': 10}]), child_errors=exp_child_errors) doc = {'prop1': 5.5} assert_fail(doc, schema) doc = {'prop1': '5.5'} assert_fail(doc, schema)
def test_multiples_exclusions(): schema = {'this_field': {'type': 'dict', 'excludes': ['that_field', 'bazo_field']}, 'that_field': {'type': 'dict', 'excludes': 'this_field'}, 'bazo_field': {'type': 'dict'}} assert_success({'this_field': {}}, schema) assert_success({'that_field': {}}, schema) assert_fail({'this_field': {}, 'that_field': {}}, schema) assert_fail({'this_field': {}, 'bazo_field': {}}, schema) assert_fail({'that_field': {}, 'this_field': {}, 'bazo_field': {}}, schema) assert_success({'that_field': {}, 'bazo_field': {}}, schema)
def test_require_all_simple(): schema = {'foo': {'type': 'string'}} validator = Validator(require_all=True) assert_fail( {}, schema, validator, error=('foo', '__require_all__', errors.REQUIRED_FIELD, True), ) assert_success({'foo': 'bar'}, schema, validator) validator.require_all = False assert_success({}, schema, validator) assert_success({'foo': 'bar'}, schema, validator)
def test_anyof_2(): # these two schema should be the same schema1 = {'prop': {'anyof': [{'type': 'dict', 'schema': { 'val': {'type': 'integer'}}}, {'type': 'dict', 'schema': { 'val': {'type': 'string'}}}]}} schema2 = {'prop': {'type': 'dict', 'anyof': [ {'schema': {'val': {'type': 'integer'}}}, {'schema': {'val': {'type': 'string'}}}]}} doc = {'prop': {'val': 0}} assert_success(doc, schema1) assert_success(doc, schema2) doc = {'prop': {'val': '0'}} assert_success(doc, schema1) assert_success(doc, schema2) doc = {'prop': {'val': 1.1}} assert_fail(doc, schema1) assert_fail(doc, schema2)
def test_anyof_allof(): # prop1 can be any number outside of [0-10] schema = {'prop1': {'allof': [{'anyof': [{'type': 'float'}, {'type': 'integer'}]}, {'anyof': [{'min': 10}, {'max': 0}]} ]}} doc = {'prop1': 11} assert_success(doc, schema) doc = {'prop1': -1} assert_success(doc, schema) doc = {'prop1': 5} assert_fail(doc, schema) doc = {'prop1': 11.5} assert_success(doc, schema) doc = {'prop1': -1.5} assert_success(doc, schema) doc = {'prop1': 5.5} assert_fail(doc, schema) doc = {'prop1': '5.5'} assert_fail(doc, schema)
def test_require_all_override_by_subdoc_require_all(validator_require_all, sub_doc_require_all): sub_schema = {"bar": {"type": "string"}} schema = { "foo": { "type": "dict", "require_all": sub_doc_require_all, "schema": sub_schema, } } validator = Validator(require_all=validator_require_all) assert_success({"foo": {"bar": "baz"}}, schema, validator) if validator_require_all: assert_fail({}, schema, validator) else: assert_success({}, schema, validator) if sub_doc_require_all: assert_fail({"foo": {}}, schema, validator) else: assert_success({"foo": {}}, schema, validator)
def test_expansion_with_unvalidated_schema(): validator = UnconcernedValidator( {"field": {'allof_regex': ['^Aladdin .*', '.* Sane$']}} ) assert_success(document={"field": "Aladdin Sane"}, validator=validator)
def test_schema_registry_simple(): schema_registry.add('foo', {'bar': {'type': 'string'}}) schema = {'a': {'schema': 'foo'}, 'b': {'schema': 'foo'}} document = {'a': {'bar': 'a'}, 'b': {'bar': 'b'}} assert_success(document, schema)
def test_rules_registry_with_anyof_type(): rules_set_registry.add('string_or_integer', {'anyof_type': ['string', 'integer']}) schema = {'soi': 'string_or_integer'} assert_success({'soi': 'hello'}, schema)
def test_recursion(): rules_set_registry.add('self', {'type': 'dict', 'allow_unknown': 'self'}) v = Validator(allow_unknown='self') assert_success({0: {1: {2: {}}}}, {}, v)
def test_allow_unknown_as_reference(): rules_set_registry.add('foo', {'type': 'number'}) v = Validator(allow_unknown='foo') assert_success({0: 1}, {}, v) assert_fail({0: 'one'}, {}, v)
def test_rules_set_simple(): rules_set_registry.add('foo', {'type': 'integer'}) assert_success({'bar': 1}, {'bar': 'foo'}) assert_fail({'bar': 'one'}, {'bar': 'foo'})