def test_schema_registry_with_anyof_type(): schema_registry.add('soi_id', {'id': { 'anyof_type': ['string', 'integer'] }}) schema = {'soi': {'schema': 'soi_id'}} assert_success({'soi': {'id': 'hello'}}, 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_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_rules_set_with_dict_field(): document = {'a_dict': {'foo': 1}} schema = {'a_dict': {'type': 'dict', 'schema': {'foo': 'rule'}}} # the schema's not yet added to the valid ones, so test the faulty first rules_set_registry.add('rule', {'tüpe': 'integer'}) assert_schema_error(document, schema) rules_set_registry.add('rule', {'type': 'integer'}) assert_success(document, schema)
def test_validator_method(rule): class MyValidator(cerberus.Validator): def _validator_oddity(self, field, value): if not value & 1: self._error(field, "Must be an odd number") v = MyValidator(schema={'amount': {rule: 'oddity'}}) assert_success(document={'amount': 1}, validator=v) assert_fail( document={'amount': 2}, validator=v, error=('amount', (), cerberus.errors.CUSTOM, None, ('Must be an odd number', )), )
def test_check_with_method(rule): # https://github.com/pyeve/cerberus/issues/265 class MyValidator(cerberus.Validator): def _check_with_oddity(self, field, value): if not value & 1: self._error(field, "Must be an odd number") v = MyValidator(schema={'amount': {rule: 'oddity'}}) assert_success(document={'amount': 1}, validator=v) assert_fail( document={'amount': 2}, validator=v, error=('amount', (), cerberus.errors.CUSTOM, None, ('Must be an odd number', )), )
def test_dynamic_types(): decimal_type = TypeDefinition("decimal", (Decimal, ), ()) document = {"measurement": Decimal(0)} schema = {"measurement": {"type": "decimal"}} validator = Validator() validator.types_mapping["decimal"] = decimal_type assert_success(document, schema, validator) class MyValidator(Validator): types_mapping = Validator.types_mapping.copy() types_mapping["decimal"] = decimal_type validator = MyValidator() assert_success(document, schema, validator)
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_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_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'})
def test_top_level_reference(): schema_registry.add('peng', {'foo': {'type': 'integer'}}) document = {'foo': 42} assert_success(document, 'peng')
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)