class TestDataCatalyst(Catalyst):
string = StringField(min_length=2,
max_length=12,
dump_default='default',
load_default='default')
integer = IntegerField(minimum=0, maximum=12, load_required=True)
float_field = FloatField(name='float_',
key='float',
minimum=-1.1,
maximum=1.1)
bool_field = BooleanField(name='bool_', key='bool')
func = CallableField(name='func', key='func', func_args=(1, 2, 3))
list_ = ListField(StringField())
def test_sum_fields(self):
decimal_field = DecimalField()
class SumCatalyst(Catalyst):
a = IntegerField()
b = IntegerField()
total = SumFields(decimal_field, declared_fields='*')
catalyst = SumCatalyst()
self.assertSetEqual(set(catalyst.total.fields), {'a', 'b'})
data = {'a': 1, 'b': 2}
result = catalyst.dump(data)
self.assertTrue(result.is_valid)
self.assertEqual(result.valid_data['total'], '3')
result = catalyst.load(data)
self.assertTrue(result.is_valid)
self.assertEqual(result.valid_data['total'],
decimal_field.to_decimal(3))
# wrong type
with self.assertRaises(TypeError):
SumFields('xxx')
with self.assertRaises(TypeError):
SumCatalyst.total.set_fields({'x': StringField()})
def test_nest_field(self):
with self.assertRaises(TypeError):
NestedField()
with self.assertRaises(TypeError):
field = NestedField(Catalyst)
fields = {'name': StringField(max_length=3)}
field = NestedField(Catalyst(fields), name='a', key='a')
self.assertEqual(field.dump({'name': '1'}), {'name': '1'})
self.assertEqual(field.dump({'name': '1234'}), {'name': '1234'})
with self.assertRaises(ValidationError):
field.dump({'n': 'm'})
with self.assertRaises(ValidationError):
field.dump(1)
self.assertEqual(field.load({'name': '1'}), {'name': '1'})
self.assertDictEqual(field.load({'n': 'm'}), {})
with self.assertRaises(ValidationError):
field.load({'name': '1234'})
with self.assertRaises(ValidationError):
field.load(1)
# list with dict items
field = NestedField(Catalyst({'x': IntegerField()}), many=True)
data = [{'x': 1}, {'x': 2}]
self.assertListEqual(data, field.load(data))
data = [{'x': 1}, {'x': 'x'}]
with self.assertRaises(ValidationError) as cm:
field.load(data)
result = cm.exception.detail
self.assertIsInstance(result.errors[1]['x'], ValueError)
data = [{'x': 1}, None]
with self.assertRaises(ValidationError) as cm:
field.load(data)
result = cm.exception.detail
self.assertIsInstance(result.errors[1]['load'], TypeError)
class C:
c = StringField()
class C(Catalyst):
s = StringField(min_length=1, max_length=2)
class BA_2(NoAC):
a = StringField()
class BA_1(ACNone, B):
a = StringField()
class C(Catalyst):
raise_error = True
s = StringField(**kwargs)
class Article(Catalyst):
title = StringField()
content = StringField()
author = NestedField(user_catalyst)
class User(Catalyst):
uid = IntegerField()
name = StringField()
class A(Catalyst):
raise_error = True
a = IntegerField()
b = StringField()
def test_string_field(self):
field = StringField(
name='string',
key='string',
min_length=2,
max_length=12,
error_messages={'not_between': 'Must >= {self.minimum}'})
# dump
self.assertEqual(field.dump('xxx'), 'xxx')
self.assertEqual(field.dump(1), '1')
self.assertEqual(field.dump([]), '[]')
self.assertEqual(field.dump(None), None)
# load
self.assertEqual(field.load('xxx'), 'xxx')
self.assertEqual(field.load(123), '123')
self.assertEqual(field.load([1]), '[1]')
self.assertEqual(field.load(None), None)
with self.assertRaises(ValidationError) as cm:
field.load('')
# change validator's error message
self.assertEqual(cm.exception.msg, 'Must >= 2')
self.assertEqual(field.error_messages['not_between'],
field.validators[0].error_messages['not_between'])
field.allow_none = False
with self.assertRaises(ValidationError):
field.load(None)
# match regex
field = StringField(
regex='a',
error_messages={'no_match': 'not match "{self.regex.pattern}"'})
self.assertEqual(field.load('a'), 'a')
with self.assertRaises(ValidationError) as cm:
field.load('')
self.assertEqual(cm.exception.msg, 'not match "a"')