def test_between_malformed_non_integer(self):
v = Validator()
try:
v.make(fields = {'test': '5char'}, rules = {'test': 'between:omagad,omagaaaad'})
except ValueError as e:
self.assertRaisesRegexp(e, 'constraint is not a valid integer')
def test_method_failed_validation_pass(self):
fields = {'myField': 'itsa me, mario !'}
rules = {'myField': 'required'}
v = Validator(fields = fields, rules = rules)
self.assertFalse(v.failed())
def test_between_malformed(self):
v = Validator()
try:
v.make(fields = {'test': '5char'}, rules = {'test': 'between'})
except ValueError as e:
self.assertRaisesRegexp(e, 'constraints are missing from the validation rule')
def test_malformed_dict_extend(self):
new_rule = 'somegibberish'
v = Validator()
try:
v.extend(new_rule)
except TypeError as e:
self.assertRaisesRegexp(e, 'custom rule must be a dict')
def test_method_failed_validation_fail(self):
fields = {'myField': ''}
rules = {'myField': 'required|email'}
v = Validator(fields = fields, rules = rules)
### v.failed contains a list of failed validations, and their respective fields
### should print : [{u'myField': u'required'}, {u'myField': u'email'}]
self.assertTrue(v.failed())
def test_wellformed_all_validation_pass_message_reset_pass(self):
fields = {'myField': 'itsa me, mario !'}
rules = {'myField': 'required'}
messages = {'required': '{} is required'}
v = Validator(fields = fields, rules = rules, messages = messages)
self.assertFalse(v.fails())
self.assertFalse(v.errors())
def test_email_locale_fr_fail(self):
i18n.switch_language('fr')
v = Validator(fields = {'test': 'bademail.com'}, rules = {'test': 'email'})
self.assertTrue(v.fails())
self.assertTrue('test doit être un email valide' in v.errors())
### Switching back locale to English to avoid that other tests fail ! ###
i18n.switch_language('en')
def test_email_locale_jp_fail(self):
i18n.switch_language('ja')
v = Validator(fields = {'test': 'bademail.com'}, rules = {'test': 'email'})
self.assertTrue(v.fails())
self.assertTrue('testに正しい形式をご指定ください。' in v.errors())
### Switching back locale to English to avoid that other tests fail ! ###
i18n.switch_language('en')
def test_malformed_method_extend(self):
self.falsemethod = ''
new_rule = {'new_rule': self.falsemethod}
v = Validator()
try:
v.extend(new_rule)
except TypeError as e:
self.assertRaisesRegexp(e, 'custom rule is not a callable')
def test_wellformed_all_validation_pass(self):
fields = {'myField': 'itsa me, mario !'}
rules = {'myField': 'required'}
""" Error message is the opposite of the "rule" on purpose """
messages = {'required': '{} is never required'}
v = Validator(fields = fields, rules = rules, messages = messages)
self.assertFalse(v.fails())
self.assertFalse(v.errors())
def test_wellformed_all_validation_fail(self):
fields = {'myField': ''}
rules = {'myField': 'required'}
""" Error message is the opposite of the "rule" on purpose """
messages = {'required': '{} is never required'}
v = Validator(fields = fields, rules = rules, messages = messages)
self.assertTrue(v.fails())
self.assertTrue('myField is never required' in v.errors())
def test_custom_rule_fail(self):
v = Validator()
v.extend({'myrule': self.customRule})
v.make(fields = {'test': 5}, rules = {'test': 'myrule'}, messages = {'myrule' : '{0} is not equal to 1'})
self.assertTrue(v.fails())
self.assertTrue('test is not equal to 1' in v.errors())
def test_malformed_field_argument_constructor(self):
wrongfields = ''
rules = {'myField': 'required'}
try :
v = Validator(fields = wrongfields, rules = rules)
except TypeError as e:
self.assertRaisesRegexp(e, 'field data must be a dict')
def test_malformed_rules_argument_constructor(self):
fields = {'myField': 'some data'}
wrongrules = None
try :
v = Validator(fields = fields, rules = wrongrules)
except TypeError as e:
self.assertRaisesRegexp(e, 'rules data must be a dict')
def test_wellformed_field_no_corresponding_rule(self):
fields = {'myField': 'some data'}
rules = {'myField2': 'required'}
try :
v = Validator(fields = fields, rules = rules)
except ValueError as e:
self.assertRaisesRegexp(e, 'fields do not correspond to rules')
def test_wellformed_field_no_corresponding_message(self):
fields = {'myField': 'some data'}
rules = {'myField': 'required'}
messages = {'requiredd': '{} is not required'}
try :
v = Validator(fields = fields, rules = rules, messages = messages)
except ValueError as e:
self.assertRaisesRegexp(e, 'custom validation messages do not correspond to rule list')
def test_malformed_messages_argument_constructor(self):
fields = {'myField': 'some data'}
rules = {'myField': 'required'}
wrongmessages = ''
try :
v = Validator(fields = fields, rules = rules, messages = wrongmessages)
except TypeError as e:
self.assertRaisesRegexp(e, 'custom error messages must be contained in a dict')
def test_method_extend_pass_pass(self):
messages = {'new_rule': '{} is less than 10 !!'}
new_rule = {'new_rule': self.good_method}
fields = {'cars': 12}
rules = {'cars': 'new_rule'}
v = Validator()
v.extend(new_rule)
v.make(fields = fields, rules = rules, messages = messages)
self.assertFalse(v.fails())
self.assertFalse(v.errors())
def test_direct_validate_fail(self):
v = Validator()
v.validate('gibberish', 'url')
self.assertTrue(v.fails())
self.assertTrue('gibberish must be a valid url' in v.errors())
def test_direct_validate_multiple_fail(self):
v = Validator()
v.validate(22, 'min:43')
self.assertTrue(v.fails())
self.assertTrue('22 must be higher than 43' in v.errors())
def test_direct_validate_pass(self):
v = Validator()
v.validate('http://google.com', 'url')
self.assertFalse(v.fails())
self.assertFalse(v.errors())
def test_verify_messages_fail(self):
v = Validator()
v.rules = {'myField': 'required'}
v.fields = {'myField': 'Hello World'}
v.messages_temp = {'requared': 'this thing is going to crash !!'}
try:
v.verify_fields()
except ValueError as e:
self.assertRaisesRegexp(e, 'custom validation messages do not correspond to rule list')
def test_verify_rules_fields_fail(self):
v = Validator()
v.rules = {'myField': 'required'}
v.fields = {'myfield': 'Hello World'}
try:
v.verify_fields()
except ValueError as e:
self.assertRaisesRegexp(e, 'fields do not correspond to rules')
def test_multile_fields_rule_fail(self):
v = Validator()
to_test = {
'name': 'Ken',
'email': 'ken.fake-email.com',
}
rules = {
'name': 'required',
'email': 'required|email',
}
v.make(fields = to_test, rules = rules)
self.assertTrue(v.fails())
self.assertTrue('email must be a valid email' in v.errors())
def test_multile_fields_rule_pass(self):
v = Validator()
to_test = {
'name': 'Ken',
'email': '*****@*****.**',
}
rules = {
'name': 'required',
'email': 'required|email',
}
v.make(fields = to_test, rules = rules)
self.assertFalse(v.fails())
self.assertFalse(v.errors())
def test_date_rule_pass(self):
v = Validator(fields = {'test': '2451-09-12'}, rules = {'test': 'date:%Y-%m-%d'})
self.assertFalse(v.fails())
self.assertFalse(v.errors())
def test_between_string_fail(self):
v = Validator(fields = {'test': '7charss'}, rules = {'test': 'between:8,10'})
self.assertTrue(v.fails())
self.assertTrue('test\'s length must be between 8 and 10 characters' in v.errors())
def test_multiple_rule_pass(self):
v = Validator(fields = {'test': '*****@*****.**'}, rules = {'test': 'required|email'})
self.assertFalse(v.fails())
self.assertFalse(v.errors())
def test_integer_as_integer_pass(self):
v = Validator(fields = {'test': 25}, rules = {'test': 'integer'})
self.assertFalse(v.fails())
self.assertFalse(v.errors())
def test_integer_as_string_fail(self):
v = Validator(fields = {'test': '-10a'}, rules = {'test': 'integer'})
self.assertTrue(v.fails())
self.assertTrue("test must be an integer" in v.errors())
def test_between_integer_fail(self):
v = Validator(fields = {'test': 5}, rules = {'test': 'between:8,10'})
self.assertTrue(v.fails())
self.assertTrue('test\'s value must be higher than 8 and lower than 10' in v.errors())
def test_date_rule_fail(self):
v = Validator(fields = {'test': '2451-df-1234'}, rules = {'test': 'date:%Y-%m-%d'})
self.assertTrue(v.fails())
self.assertTrue('test is not a valid date, the format must be %Y-%m-%d' in v.errors())
def test_max_string_integer_pass(self):
v = Validator(fields = {'test': '7'}, rules = {'test': 'max:8'})
self.assertFalse(v.fails())
self.assertFalse(v.errors())
def test_multiple_rule_fail2(self):
v = Validator(fields = {'test': 'myvalue'}, rules = {'test': 'required|email'})
self.assertTrue(v.fails())
self.assertTrue('test is required' not in v.errors())
self.assertTrue('test must be a valid email' in v.errors())
def test_between_string_integer_pass(self):
v = Validator(fields = {'test': '9'}, rules = {'test': 'between:8,10'})
self.assertFalse(v.fails())
self.assertFalse(v.errors())
