def test_tuple(self): with pytest.raises(TypeError): Tuple(UnicodeString(), Integer(), Boolean(), additional_validator='Not a validator') # type: ignore field = Tuple(UnicodeString(), Integer(), Boolean()) assert field.errors(['foo', 'bar', 'baz']) == [Error(message='Not a tuple')] assert field.errors({'foo': 'bar'}) == [Error(message='Not a tuple')] assert field.errors({'foo', 'bar', 'baz'}) == [Error(message='Not a tuple')] assert field.errors( ('foo', 'bar', True)) == [Error(message='Not an integer', pointer='1')] assert field.errors(('foo', 12, False)) == [] assert field.errors(('foo', 12, True)) == [] class V(AdditionalCollectionValidator[TupleType[AnyType]]): def errors(self, value): if value[2] is not True: return [Error('The third value must be True', pointer='2')] return [] field = Tuple(UnicodeString(), Integer(), Boolean(), additional_validator=V()) assert field.errors(('foo', 12, False)) == [ Error(message='The third value must be True', pointer='2') ] assert field.errors(('foo', 12, True)) == []
def test_tuple(self): schema = Tuple(Integer(gt=0), UnicodeString(), Constant('I love tuples')) self.assertEqual(schema.errors((1, 'test', 'I love tuples')), []) # too short self.assertEqual( schema.errors((1, 'test')), [Error('Number of elements 2 does not match expected 3')]) # too long self.assertEqual( schema.errors((1, 'test', 'I love tuples', '... and coffee')), [Error('Number of elements 4 does not match expected 3')]) self.assertEqual(schema.errors(( -1, None, 'I hate tuples', )), [ Error('Value not > 0', pointer='0'), Error('Not a unicode string', pointer='1'), Error( 'Value is not "I love tuples"', code=ERROR_CODE_UNKNOWN, pointer='2', ), ]) self.assertEqual( schema.introspect(), { 'type': 'tuple', 'contents': [ { 'type': 'integer', 'gt': 0 }, { 'type': 'unicode' }, { 'type': 'constant', 'values': ['I love tuples'] }, ] })
class Helper(object): @classmethod @validate_method(schema, UnicodeString()) def greeter(cls, name, greeting='Hello'): # Special case to check return value stuff if name == 'error': return 5 return '{}, {}!'.format(greeting, name) @staticmethod @validate_call(args=Tuple(Integer(), Integer()), kwargs=None, returns=Integer()) def args_method(one, two): return one + two # noinspection PyMethodMayBeStatic @validate_method( args=List(UnicodeString()), kwargs=SchemalessDictionary(value_type=UnicodeString()), returns=List(UnicodeString()), ) def args_and_kwargs_method(self, *args, **kwargs): return [s.format(**kwargs) for s in args]
def test_tuple(self): # type: () -> None schema = Tuple(Integer(gt=0), UnicodeString(), Constant('I love tuples')) self.assertEqual(schema.errors((1, 'test', 'I love tuples')), []) # too short self.assertEqual( schema.errors((1, 'test')), [Error('Number of elements 2 does not match expected 3')]) # too long self.assertEqual( schema.errors((1, 'test', 'I love tuples', '... and coffee')), [Error('Number of elements 4 does not match expected 3')]) self.assertEqual(schema.errors(( -1, None, 'I hate tuples', )), [ Error('Value not > 0', pointer='0'), Error('Not a unicode string', pointer='1'), Error( 'Value is not "I love tuples"', code=ERROR_CODE_UNKNOWN, pointer='2', ), ]) self.assertEqual( schema.introspect(), { 'type': 'tuple', 'contents': [ { 'type': 'integer', 'gt': 0 }, { 'type': 'unicode' }, { 'type': 'constant', 'values': ['I love tuples'] }, ] }) with pytest.raises(TypeError): # noinspection PyTypeChecker Tuple('not a field') # type: ignore with pytest.raises(TypeError): Tuple(Integer(gt=0), UnicodeString(), Constant('I love tuples'), description=b'Not a unicode string') with pytest.raises(TypeError): Tuple(Integer(gt=0), UnicodeString(), Constant('I love tuples'), unsupported='argument')
def test_dictionary_ordering(self): # type: () -> None schema1 = Dictionary( OrderedDict(( ('foo', UnicodeString()), ('bar', Boolean()), ('baz', List(Integer())), )), optional_keys=('foo', ), description='Hello, world', ) assert schema1.introspect()['contents'] == { 'baz': List(Integer()).introspect(), 'foo': UnicodeString().introspect(), 'bar': Boolean().introspect(), } assert schema1.introspect()['display_order'] == ['foo', 'bar', 'baz'] schema2 = schema1.extend( OrderedDict(( ('bar', Integer()), ('qux', Set(UnicodeString())), ('moon', Tuple(Decimal(), UnicodeString())), ))) assert schema2.introspect()['contents'] == { 'baz': List(Integer()).introspect(), 'foo': UnicodeString().introspect(), 'moon': Tuple(Decimal(), UnicodeString()).introspect(), 'bar': Integer().introspect(), 'qux': Set(UnicodeString()).introspect(), } assert schema2.introspect()['display_order'] == [ 'foo', 'bar', 'baz', 'qux', 'moon' ] assert not schema1.errors({'bar': True, 'foo': 'Hello', 'baz': [15]}) errors = schema1.errors({ 'baz': 'Nope', 'foo': False, 'bar': ['Heck nope'] }) assert errors == [ Error(code='INVALID', pointer='foo', message='Not a unicode string'), Error(code='INVALID', pointer='bar', message='Not a boolean'), Error(code='INVALID', pointer='baz', message='Not a list'), ] assert not schema2.errors( { 'bar': 91, 'foo': 'Hello', 'qux': {'Yes'}, 'baz': [15], 'moon': (decimal.Decimal('15.25'), 'USD') }, ) errors = schema2.errors({ 'baz': 'Nope', 'foo': False, 'bar': ['Heck nope'], 'qux': 'Denied', 'moon': 72 }) assert errors == [ Error(code='INVALID', pointer='foo', message='Not a unicode string'), Error(code='INVALID', pointer='bar', message='Not an integer'), Error(code='INVALID', pointer='baz', message='Not a list'), Error(code='INVALID', pointer='qux', message='Not a set or frozenset'), Error(code='INVALID', pointer='moon', message='Not a tuple'), ]
def test_validate_call(self): # type: () -> None schema = Dictionary({ 'name': UnicodeString(max_length=20), 'greeting': UnicodeString(), }, optional_keys=('greeting', )) @validate_call(schema, UnicodeString()) def greeter(name, greeting='Hello'): # Special case to check return value stuff if name == 'error': return 5 return '{}, {}!'.format(greeting, name) assert getattr(greeter, '__validated__') is True assert getattr(greeter, '__validated_schema_args__') is None assert getattr(greeter, '__validated_schema_kwargs__') is schema assert getattr(greeter, '__validated_schema_returns__') == UnicodeString() self.assertEqual(greeter(name='Andrew'), 'Hello, Andrew!') self.assertEqual(greeter(name='Andrew', greeting='Ahoy'), 'Ahoy, Andrew!') with self.assertRaises(ValidationError): greeter(name='Andrewverylongnameperson') with self.assertRaises(ValidationError): greeter(name='Andrew', greeeeeeting='Boo') with self.assertRaises(ValidationError): greeter(name='error') with self.assertRaises(PositionalError): greeter('Andrew') @validate_call( args=Tuple(Integer(), UnicodeString()), kwargs=None, returns=Null(), ) def args_function(foo, bar): if foo: return bar.format(bar) assert getattr(args_function, '__validated__') is True assert getattr(args_function, '__validated_schema_args__') == Tuple(Integer(), UnicodeString()) assert getattr(args_function, '__validated_schema_kwargs__') is None assert getattr(args_function, '__validated_schema_returns__') == Null() assert args_function(0, 'John {}') is None with pytest.raises(ValidationError): args_function(1, 'Jeff {}') with pytest.raises(ValidationError): args_function(0, b'Nope {}') with pytest.raises(ValidationError): args_function(0, bar='John {}') with pytest.raises(KeywordError): args_function(0, 'John {}', extra='Unsupported') @validate_call( args=Tuple(Integer(), UnicodeString()), kwargs=Dictionary({'extra': UnicodeString()}, optional_keys=('extra', )), returns=UnicodeString(), ) def args_and_kwargs_function(foo, bar, extra='baz'): return bar.format(foo, extra) assert getattr(args_and_kwargs_function, '__validated__') is True assert getattr(args_and_kwargs_function, '__validated_schema_args__') == Tuple(Integer(), UnicodeString()) assert ( getattr(args_and_kwargs_function, '__validated_schema_kwargs__') == Dictionary({'extra': UnicodeString()}, optional_keys=('extra', )) ) assert getattr(args_and_kwargs_function, '__validated_schema_returns__') == UnicodeString() assert args_and_kwargs_function(0, 'John {}: {}') == 'John 0: baz' assert args_and_kwargs_function(1, 'Jeff {}: {}', extra='cool') == 'Jeff 1: cool' with pytest.raises(ValidationError): args_and_kwargs_function(1, 'Jeff {}: {}', 'cool') with pytest.raises(ValidationError): args_and_kwargs_function('nope', 'Jeff {}: {}') with pytest.raises(ValidationError): args_and_kwargs_function(1, b'nope') with pytest.raises(ValidationError): args_and_kwargs_function(0, bar='John {}: {}')
def test_validate_method(self): # type: () -> None schema = Dictionary({ 'name': UnicodeString(max_length=20), 'greeting': UnicodeString(), }, optional_keys=('greeting', )) class Helper(object): @classmethod @validate_method(schema, UnicodeString()) def greeter(cls, name, greeting='Hello'): # Special case to check return value stuff if name == 'error': return 5 return '{}, {}!'.format(greeting, name) @staticmethod @validate_call(args=Tuple(Integer(), Integer()), kwargs=None, returns=Integer()) def args_method(one, two): return one + two # noinspection PyMethodMayBeStatic @validate_method( args=List(UnicodeString()), kwargs=SchemalessDictionary(value_type=UnicodeString()), returns=List(UnicodeString()), ) def args_and_kwargs_method(self, *args, **kwargs): return [s.format(**kwargs) for s in args] assert getattr(Helper.greeter, '__validated__') is True assert getattr(Helper.greeter, '__validated_schema_args__') is None assert getattr(Helper.greeter, '__validated_schema_kwargs__') is schema assert getattr(Helper.greeter, '__validated_schema_returns__') == UnicodeString() assert getattr(Helper.args_method, '__validated__') is True assert getattr(Helper.args_method, '__validated_schema_args__') == Tuple(Integer(), Integer()) assert getattr(Helper.args_method, '__validated_schema_kwargs__') is None assert getattr(Helper.args_method, '__validated_schema_returns__') == Integer() assert getattr(Helper.args_and_kwargs_method, '__validated__') is True assert getattr(Helper.args_and_kwargs_method, '__validated_schema_args__') == List(UnicodeString()) assert ( getattr(Helper.args_and_kwargs_method, '__validated_schema_kwargs__') == SchemalessDictionary(value_type=UnicodeString()) ) assert getattr(Helper.args_and_kwargs_method, '__validated_schema_returns__') == List(UnicodeString()) self.assertEqual(Helper.greeter(name='Andrew'), 'Hello, Andrew!') self.assertEqual(Helper.greeter(name='Andrew', greeting='Ahoy'), 'Ahoy, Andrew!') with self.assertRaises(ValidationError): Helper.greeter(name='Andrewverylongnameperson') with self.assertRaises(ValidationError): Helper.greeter(name='Andrew', greeeeeeting='Boo') with self.assertRaises(ValidationError): Helper.greeter(name='error') with self.assertRaises(PositionalError): Helper.greeter('Andrew') assert Helper.args_method(1, 2) == 3 assert Helper.args_method(75, 23) == 98 with pytest.raises(ValidationError): Helper.args_method(1.0, 2) with pytest.raises(ValidationError): Helper.args_method(1, 2.0) with pytest.raises(KeywordError): Helper.args_method(1, 2, extra='Forbidden') assert Helper().args_and_kwargs_method('hello', 'cool {planet}', 'hot {star}', planet='Earth', star='Sun') == [ 'hello', 'cool Earth', 'hot Sun', ] with pytest.raises(ValidationError): Helper().args_and_kwargs_method(1, 'sweet', planet='Earth', star='Sun') with pytest.raises(ValidationError): Helper().args_and_kwargs_method('hello', 'cool {planet}', 'hot {star}', planet=1, star=2)