def test_dot_length(self):
validate = Validator().validate(
{'user': {
'id': 1,
'email': '*****@*****.**'
}}, length(['user.id'], min=1, max=10))
self.assertEqual(len(validate), 0)
validate = Validator().validate(
{
'user': {
'id': 1,
'email': '*****@*****.**',
'description': 'this is a really long description'
}
}, length(['user.id'], '1..10'))
self.assertEqual(len(validate), 0)
validate = Validator().validate(
{
'user': {
'id': 1,
'email': '*****@*****.**',
'description': 'this is a really long description'
}
}, length(['user.description'], min=1, max=10))
self.assertEqual(
validate, {
'user.description':
['The user.description length must be between 1 and 10.']
})
def test_confirmed(self):
validate = Validator().validate(
{
'password': '******',
'password_confirmation': 'secret',
}, confirmed(['password']))
self.assertEqual(len(validate), 0)
validate = Validator().validate({
'password': '******',
}, confirmed(['password']))
self.assertEqual(
validate,
{'password': ['The password confirmation does not match.']})
validate = Validator().validate({}, confirmed(['password']))
self.assertEqual(
validate,
{'password': ['The password confirmation does not match.']})
validate = Validator().validate(
{
'password': '******',
'password_confirmation': 'foo',
}, confirmed(['password']))
self.assertEqual(
validate,
{'password': ['The password confirmation does not match.']})
def test_one_of(self):
validate = Validator().validate(
{
'email': '*****@*****.**',
'phone': '123-456-7890'
}, one_of(['email', 'phone']))
self.assertEqual(len(validate), 0)
validate = Validator().validate({
'accepted': 'on',
'user': '******'
}, one_of(['email', 'phone']))
self.assertEqual(validate['email'],
['The email or phone is required.'])
self.assertEqual(validate['phone'],
['The email or phone is required.'])
validate = Validator().validate({
'accepted': 'on',
'user': '******'
}, one_of(['email', 'phone', 'password']))
self.assertEqual(validate['email'],
['The email, phone, password is required.'])
validate = Validator().validate({
'accepted': 'on',
'user': '******'
}, one_of(['email', 'phone', 'password', 'user']))
self.assertEqual(len(validate), 0)
def test_when(self):
validate = Validator().validate(
{
'email': '*****@*****.**',
'phone': '123-456-7890'
},
when(isnt(required('email'))).then(required('phone')))
self.assertEqual(len(validate), 0)
validate = Validator().validate({'email': '*****@*****.**'},
when(exists('email')).then(
required('phone')))
self.assertEqual(validate['phone'], ['The phone field is required.'])
validate = Validator().validate({'user': '******'},
when(exists('email')).then(
required('phone')))
self.assertEqual(len(validate), 0)
validate = Validator().validate({
'email': '*****@*****.**',
},
when(does_not(exists('email'))).then(
required('phone')))
self.assertEqual(len(validate), 0)
def test_dot_error_message_required(self):
validate = Validator().validate(
{'user': {
'id': 1,
'email': '*****@*****.**',
'age': 25
}},
required(
['user.description'],
messages={'user.description':
'You are missing a description'}))
self.assertEqual(
validate, {'user.description': ['You are missing a description']})
validate = Validator().validate(
{'user': {
'id': 1,
'email': '*****@*****.**'
}},
required(['user.id', 'user.email', 'user.age'],
messages={'user.age': 'You are missing a user age'}))
self.assertEqual(validate,
{'user.age': ['You are missing a user age']})
def test_string(self):
validate = Validator().validate({'text': 'hey'}, string(['text']))
self.assertEqual(len(validate), 0)
validate = Validator().validate({'text': 1}, string(['text']))
self.assertEqual(validate, {'text': ['The text must be a string.']})
def test_accepted(self):
validate = Validator().validate({'terms': 'on'}, accepted(['terms']))
self.assertEqual(len(validate), 0)
validate = Validator().validate({'terms': 'test'}, accepted(['terms']))
self.assertEqual(validate, {'terms': ['The terms must be accepted.']})
def test_none(self):
validate = Validator().validate({'text': None}, none(['text']))
self.assertEqual(len(validate), 0)
validate = Validator().validate({'text': 1}, none(['text']))
self.assertEqual(validate, {'text': ['The text must be None.']})
def test_numeric(self):
validate = Validator().validate({'test': 1}, numeric(['test']))
self.assertEqual(len(validate), 0)
validate = Validator().validate({'test': 'hey'}, numeric(['test']))
self.assertEqual(validate, {'test': ['The test must be a numeric.']})
def test_less_than(self):
validate = Validator().validate({'text': 10}, less_than(['text'], 25))
self.assertEqual(len(validate), 0)
validate = Validator().validate({'text': 101}, less_than(['text'], 75))
self.assertEqual(validate,
{'text': ['The text must be less than 75.']})
def test_ip(self):
validate = Validator().validate({'ip': '192.168.1.1'}, ip(['ip']))
self.assertEqual(len(validate), 0)
validate = Validator().validate({'ip': 'test'}, ip(['ip']))
self.assertEqual(validate,
{'ip': ['The ip must be a valid ipv4 address.']})
def test_contains(self):
validate = Validator().validate({'test': 'this is a sentence'},
contains(['test'], 'this'))
self.assertEqual(len(validate), 0)
validate = Validator().validate({'test': 'this is a not sentence'},
contains(['test'], 'test'))
self.assertEqual(validate, {'test': ['The test must contain test.']})
def test_required(self):
validate = Validator().validate({'test': 1},
required(['user', 'email']))
self.assertEqual(validate['user'], ['The user field is required.'])
self.assertEqual(validate['email'], ['The email field is required.'])
validate = Validator().validate({'test': 1}, required(['test']))
self.assertEqual(len(validate), 0)
def test_email(self):
validate = Validator().validate({'email': '*****@*****.**'},
email(['email']))
self.assertEqual(len(validate), 0)
validate = Validator().validate({'email': 'user'}, email(['email']))
self.assertEqual(
validate, {'email': ['The email must be a valid email address.']})
def test_json(self):
validate = Validator().validate({'json': 'hey'}, vjson(['json']))
self.assertEqual(validate,
{'json': ['The json must be a valid JSON.']})
validate = Validator().validate({'json': json.dumps({'test': 'key'})},
vjson(['json']))
self.assertEqual(len(validate), 0)
def test_conditional(self):
validate = Validator().validate({'terms': 'on'},
when(accepted(['terms'])).then(
required(['user'])))
self.assertEqual(validate, {'user': ['The user field is required.']})
validate = Validator().validate({'terms': 'test'}, accepted(['terms']))
self.assertEqual(validate, {'terms': ['The terms must be accepted.']})
def test_timezone(self):
validate = Validator().validate({'timezone': 'America/New_York'},
timezone(['timezone']))
self.assertEqual(len(validate), 0)
validate = Validator().validate({'timezone': 'test'},
timezone(['timezone']))
self.assertEqual(
validate, {'timezone': ['The timezone must be a valid timezone.']})
def test_exists(self):
validate = Validator().validate({
'terms': 'on',
'user': '******',
}, exists(['user']))
self.assertEqual(len(validate), 0)
validate = Validator().validate({'terms': 'test'}, exists(['user']))
self.assertEqual(validate, {'user': ['The user must exist.']})
def test_in_range(self):
validate = Validator().validate({'text': 52},
in_range(['text'], min=25, max=72))
self.assertEqual(len(validate), 0)
validate = Validator().validate({'text': 101},
in_range(['text'], min=25, max=72))
self.assertEqual(validate,
{'text': ['The text must be between 25 and 72.']})
def test_equals(self):
validate = Validator().validate({'text': 'test1'},
equals(['text'], 'test1'))
self.assertEqual(len(validate), 0)
validate = Validator().validate({'text': 'test2'},
equals(['text'], 'test1'))
self.assertEqual(validate,
{'text': ['The text must be equal to test1.']})
def test_greater_than(self):
validate = Validator().validate({'text': 52}, greater_than(['text'],
25))
self.assertEqual(len(validate), 0)
validate = Validator().validate({'text': 101},
greater_than(['text'], 150))
self.assertEqual(validate,
{'text': ['The text must be greater than 150.']})
def test_is_in(self):
validate = Validator().validate({'test': 1}, is_in(['test'],
[1, 2, 3]))
self.assertEqual(len(validate), 0)
validate = Validator().validate({'test': 1}, is_in(['test'],
[4, 2, 3]))
self.assertEqual(
validate,
{'test': ['The test must contain an element in [4, 2, 3].']})
def test_phone(self):
validate = Validator().validate({'phone': '876-182-1921'},
phone('phone', pattern='123-456-7890'))
self.assertEqual(len(validate), 0)
validate = Validator().validate({'phone': '(876)182-1921'},
phone('phone', pattern='123-456-7890'))
self.assertEqual(
validate,
{'phone': ['The phone must be in the format XXX-XXX-XXXX.']})
def test_date(self):
validate = Validator().validate({
'date': '1975-05-21T22:00:00',
}, date(['date']))
self.assertEqual(len(validate), 0)
validate = Validator().validate({
'date': 'woop',
}, date(['date']))
self.assertEqual(validate,
{'date': ['The date must be a valid date.']})
def test_truthy(self):
validate = Validator().validate({'text': 'value'}, truthy(['text']))
self.assertEqual(len(validate), 0)
validate = Validator().validate({'text': 1}, truthy(['text']))
self.assertEqual(len(validate), 0)
validate = Validator().validate({'text': False}, truthy(['text']))
self.assertEqual(validate,
{'text': ['The text must be a truthy value.']})
def test_isnt(self):
validate = Validator().validate({'test': 50},
isnt(in_range(['test'], min=10,
max=20)))
self.assertEqual(len(validate), 0)
validate = Validator().validate({'test': 15},
isnt(in_range(['test'], min=10,
max=20)))
self.assertEqual(validate,
{'test': ['The test must not be between 10 and 20.']})
def test_dot_required(self):
validate = Validator().validate(
{'user': {
'email': '*****@*****.**'
}}, required(['user.id']))
self.assertEqual(validate,
{'user.id': ['The user.id field is required.']})
validate = Validator().validate({'user': {
'id': 1
}}, required(['user.id']))
self.assertEqual(len(validate), 0)
def test_error_message_required(self):
validate = Validator().validate(
{'test': 1},
required(['user', 'email'],
messages={'user': '******'}))
self.assertEqual(validate['user'], ['there must be a user value'])
self.assertEqual(validate['email'], ['The email field is required.'])
validate = Validator().validate(
{'test': 1},
required(['user', 'email'],
messages={'email': 'there must be an email value'}))
self.assertEqual(validate['user'], ['The user field is required.'])
self.assertEqual(validate['email'], ['there must be an email value'])
def test_isnt_equals(self):
validate = Validator().validate({'test': 'test'},
isnt(equals(['test'], 'test'),
length(['test'], min=10, max=20)))
self.assertEqual(validate,
{'test': ['The test must not be equal to test.']})
def test_enclosure_can_encapsulate_rules(self):
validate = Validator().validate(
{
'username': '******',
'email': '*****@*****.**',
'terms': 'on'
}, MockRuleEnclosure)
self.assertEqual(len(validate), 0)
validate = Validator().validate(
{
'email': '*****@*****.**',
'terms': 'on'
}, MockRuleEnclosure)
self.assertEqual(len(validate), 1)
