def test_range():
s = Schema()
s.some_number.range()
s.validate({'some_number': 4})
assert_true(s.valid)
s = Schema()
s.some_number.range(low=1)
s.validate({'some_number': 0})
assert_false(s.valid)
s.reset()
s.validate({'some_number': 1})
assert_true(s.valid)
s.reset()
s.validate({'some_number': 2})
assert_true(s.valid)
s = Schema()
s.some_number.range(high=5)
s.validate({'some_number': 6})
assert_false(s.valid)
s.reset()
s.validate({'some_number': 4})
assert_true(s.valid)
s = Schema()
s.some_number.range(low=2, high=3)
s.validate({'some_number': 2})
assert_true(s.valid)
def test_konval():
test_schema = {
u'name': IsName(),
u'email': IsEmailAddress(),
u'age': konval.types.IsType(int)
}
success_data = {
u'name': u'Peter M. Elias',
u'email': u'*****@*****.**',
u'age': 37
}
result = konval.validate(test_schema, success_data)
assert_true(result.is_valid())
fail_data = {
u'name': 123,
u'email': 1243,
u'age': 'fourteen'
}
result = konval.validate(test_schema, fail_data)
assert_false(result.is_valid())
assert_is_not_none(result.get_errors())
def test_zero():
s = Schema()
s.some_number.zero()
s.validate({'some_number': 1})
assert_false(s.valid)
s.reset()
s.validate({'some_number': 0})
assert_true(s.valid)
def test_equal():
s = Schema()
s.some_number.equal(10)
s.validate({'some_number': 11})
assert_false(s.valid)
s.reset()
s.validate({'some_number': 10})
assert_true(s.valid)
def test_maximum():
s = Schema()
s.some_number.maximum(5)
s.validate({'some_number': 6})
assert_false(s.valid)
s.reset()
s.validate({'some_number': 5})
assert_true(s.valid)
def test_minimum():
s = Schema()
s.some_number.minimum(1)
s.validate({'some_number': 0})
assert_false(s.valid)
s.reset()
s.validate({'some_number': 1})
assert_true(s.valid)
def test_has_steps(self):
"""test some has_steps examples"""
ok_(has_steps(self.two_steps['x']))
ok_(has_steps(self.two_steps_reverse['x']))
assert_false(has_steps(self.two_ramps['x']))
assert_false(has_steps(self.two_ramps_reverse['x']))
ok_(has_steps(self.two_ramps_two_steps['x']))
ok_(has_steps(self.two_ramps_two_steps_reverse['x']))
def test_has_steps(self):
"""test some has_steps examples"""
ok_(has_steps(self.two_steps['x']))
ok_(has_steps(self.two_steps_reverse['x']))
assert_false(has_steps(self.two_ramps['x']))
assert_false(has_steps(self.two_ramps_reverse['x']))
ok_(has_steps(self.two_ramps_two_steps['x']))
ok_(has_steps(self.two_ramps_two_steps_reverse['x']))
def test_datetime():
s = Schema()
s.valid_datetime.datetime()
s.invalid_datetime.datetime()
s.validate(test_data)
assert_false(s.valid)
assert_true(s.valid_datetime.valid)
assert_false(s.invalid_datetime.valid)
def test_datetime(): s = Schema() s.valid_datetime.datetime() s.invalid_datetime.datetime() s.validate(test_data) assert_false(s.valid) assert_true(s.valid_datetime.valid) assert_false(s.invalid_datetime.valid)
def test_time_between(): s = Schema() s.my_birthday.date().time_between(date(1988, 1, 1), date.today()) s.long_time_ago.date(format='american_scientific').time_between(date.today(), date(2055, 1, 1)) s.validate(test_data) assert_false(s.valid) assert_true(s.my_birthday.valid) assert_false(s.long_time_ago.valid)
def test_non_increasing(self):
"""test some non_increasing examples"""
assert_false(non_increasing(self.two_steps['x']))
ok_(non_increasing(self.two_steps_reverse['x']))
assert_false(non_increasing(self.two_ramps['x']))
ok_(non_increasing(self.two_ramps_reverse['x']))
assert_false(non_increasing(self.two_ramps_two_steps['x']))
ok_(non_increasing(self.two_ramps_two_steps_reverse['x']))
assert_false(non_increasing(self.switch_back['x']))
assert_false(non_increasing(self.switch_back_steps['x']))
def test_longint():
s = Schema()
s.integer_value.longint()
s.float_value.longint()
s.sizable_number.longint()
s.validate(test_data)
assert_false(s.valid)
assert_is_instance(s.integer_value.result, long)
assert_is_instance(s.sizable_number.result, long)
def test_non_increasing(self):
"""test some non_increasing examples"""
assert_false(non_increasing(self.two_steps['x']))
ok_(non_increasing(self.two_steps_reverse['x']))
assert_false(non_increasing(self.two_ramps['x']))
ok_(non_increasing(self.two_ramps_reverse['x']))
assert_false(non_increasing(self.two_ramps_two_steps['x']))
ok_(non_increasing(self.two_ramps_two_steps_reverse['x']))
assert_false(non_increasing(self.switch_back['x']))
assert_false(non_increasing(self.switch_back_steps['x']))
def test_time_between():
s = Schema()
s.my_birthday.date().time_between(date(1988, 1, 1), date.today())
s.long_time_ago.date(format='american_scientific').time_between(
date.today(), date(2055, 1, 1))
s.validate(test_data)
assert_false(s.valid)
assert_true(s.my_birthday.valid)
assert_false(s.long_time_ago.valid)
def test_longint():
s = Schema()
s.integer_value.longint()
s.float_value.longint()
s.sizable_number.longint()
s.validate(test_data)
assert_false(s.valid)
assert_is_instance(s.integer_value.result, long)
assert_is_instance(s.sizable_number.result, long)
def test_between():
s = Schema()
s.some_number.between(5, 10)
s.validate({'some_number': 5})
assert_false(s.valid)
s.reset()
s.validate({'some_number': 6})
assert_true(s.valid)
s.reset()
s.validate({'some_number': 10})
assert_false(s.valid)
def test_ipv4():
s = Schema()
s.valid_ipv4.ipv4()
s.invalid_ipv4.ipv4()
s.invalid_ipv42.ipv4()
s.validate(_sample_data())
assert_true(s.valid_ipv4.valid)
assert_false(s.invalid_ipv4.valid)
assert_false(s.invalid_ipv42.valid)
def test_decimal():
s = Schema()
s.decimal_value.decimal()
s.not_decimal_value.decimal()
s.string_value.decimal()
s.validate(test_data)
assert_false(s.valid)
assert_true(s.decimal_value.valid)
assert_true(s.not_decimal_value.valid)
assert_false(s.string_value.valid)
def test_nonblank():
s = Schema()
s.random_string.nonblank()
s.validate(_sample_data())
assert_true(s.valid)
s = Schema()
s.blank_string.nonblank()
s.validate(_sample_data())
assert_false(s.valid)
def test_nonblank():
s = Schema()
s.random_string.nonblank()
s.validate(_sample_data())
assert_true(s.valid)
s = Schema()
s.blank_string.nonblank()
s.validate(_sample_data())
assert_false(s.valid)
def test_time_before(): s = Schema() s.my_birthday.date().time_before(date.today()) s.far_far_away.date(format='american_scientific').time_before(date.today()) s.long_time_ago.date(format='american_scientific').time_before(date.today()) s.validate(test_data) assert_false(s.valid) assert_true(s.my_birthday.valid) assert_false(s.far_far_away.valid) # one day this assertion will be True :) assert_true(s.long_time_ago.valid)
def test_regex():
s = Schema()
s.numeric_string.regex(r'\d')
s.validate(_sample_data())
assert_true(s.valid)
s = Schema()
s.alpha_string.regex(r'\d')
s.validate(_sample_data())
assert_false(s.valid)
def test_text():
s = Schema()
s.random_string.text()
s.validate(_sample_data())
assert_true(s.valid)
s = Schema()
s.actual_numbers.text()
s.validate(_sample_data())
assert_false(s.valid)
def test_regex():
s = Schema()
s.numeric_string.regex(r'\d')
s.validate(_sample_data())
assert_true(s.valid)
s = Schema()
s.alpha_string.regex(r'\d')
s.validate(_sample_data())
assert_false(s.valid)
def test_decimal():
s = Schema()
s.decimal_value.decimal()
s.not_decimal_value.decimal()
s.string_value.decimal()
s.validate(test_data)
assert_false(s.valid)
assert_true(s.decimal_value.valid)
assert_true(s.not_decimal_value.valid)
assert_false(s.string_value.valid)
def test_text():
s = Schema()
s.random_string.text()
s.validate(_sample_data())
assert_true(s.valid)
s = Schema()
s.actual_numbers.text()
s.validate(_sample_data())
assert_false(s.valid)
def test_numeric_string():
s = Schema()
s.numeric_string.numeric_string()
s.validate(_sample_data())
assert_true(s.valid)
s = Schema()
s.actual_numbers.numeric_string()
s.validate(_sample_data())
assert_false(s.valid)
def test_numeric_string():
s = Schema()
s.numeric_string.numeric_string()
s.validate(_sample_data())
assert_true(s.valid)
s = Schema()
s.actual_numbers.numeric_string()
s.validate(_sample_data())
assert_false(s.valid)
def test_time_before():
s = Schema()
s.my_birthday.date().time_before(date.today())
s.far_far_away.date(format='american_scientific').time_before(date.today())
s.long_time_ago.date(format='american_scientific').time_before(
date.today())
s.validate(test_data)
assert_false(s.valid)
assert_true(s.my_birthday.valid)
assert_false(
s.far_far_away.valid) # one day this assertion will be True :)
assert_true(s.long_time_ago.valid)
def test_alnum():
s = Schema()
s.alnum_string.alnum()
s.validate(_sample_data())
assert_true(s.valid)
s = Schema()
s.alpha_string.alnum()
s.actual_numbers.alnum()
s.validate(_sample_data())
assert_false(s.valid)
assert_false(s.actual_numbers.valid)
assert_true(s.alpha_string.valid)
def test_key_lookup():
s = Schema()
s.some_key.key_lookup({'alpha': 1, 'bravo': 2})
s.some_nonexistent_key.key_lookup({'alpha': 1, 'bravo': 2}, nomatch='fail')
s.some_nonexistent_key_2.key_lookup({'alpha': 1, 'bravo': 2})
s.validate(_sample_data())
assert_false(s.valid)
assert_true(s.some_key.valid)
assert_equals(s.some_key.result, 1)
assert_false(s.some_nonexistent_key.valid)
assert_true(s.some_nonexistent_key_2.valid)
assert_equals(s.some_nonexistent_key_2.result, 'delta')
def test_key_lookup():
s = Schema()
s.some_key.key_lookup({'alpha': 1, 'bravo': 2})
s.some_nonexistent_key.key_lookup({'alpha': 1, 'bravo': 2}, nomatch='fail')
s.some_nonexistent_key_2.key_lookup({'alpha': 1, 'bravo': 2})
s.validate(_sample_data())
assert_false(s.valid)
assert_true(s.some_key.valid)
assert_equals(s.some_key.result, 1)
assert_false(s.some_nonexistent_key.valid)
assert_true(s.some_nonexistent_key_2.valid)
assert_equals(s.some_nonexistent_key_2.result, 'delta')
def test_alnum():
s = Schema()
s.alnum_string.alnum()
s.validate(_sample_data())
assert_true(s.valid)
s = Schema()
s.alpha_string.alnum()
s.actual_numbers.alnum()
s.validate(_sample_data())
assert_false(s.valid)
assert_false(s.actual_numbers.valid)
assert_true(s.alpha_string.valid)
def test_filter():
s = Schema()
s.first_name.text()
s.last_name.text(min_len=1, max_len=10)
d = {
'first_name': 'Jack',
'last_name': 'Bauer'
}
s.validate(d)
assert_equals(s.first_name.original, 'Jack')
assert_equals(s.first_name.result, u'Jack')
assert_true(s.last_name.valid)
d = {
'last_name': ''
}
s.reset()
s.validate(d)
assert_false(s.valid)
def test_time(): s = Schema() s.valid_time.time() s.valid_24_time.time(format='military') s.invalid_12_time.time() s.invalid_24_time.time(format='military') s.garbage_time.time() s.validate(test_data) assert_false(s.valid) assert_true(s.valid_time.valid) assert_true(s.valid_24_time.valid) assert_false(s.invalid_12_time.valid) assert_false(s.invalid_24_time.valid) assert_false(s.garbage_time.valid)
def test_time():
s = Schema()
s.valid_time.time()
s.valid_24_time.time(format='military')
s.invalid_12_time.time()
s.invalid_24_time.time(format='military')
s.garbage_time.time()
s.validate(test_data)
assert_false(s.valid)
assert_true(s.valid_time.valid)
assert_true(s.valid_24_time.valid)
assert_false(s.invalid_12_time.valid)
assert_false(s.invalid_24_time.valid)
assert_false(s.garbage_time.valid)
def test_email():
s = Schema()
s.valid_email.email()
s.invalid_email.email()
s.invalid_email2.email()
s.invalid_email3.email()
s.validate(_sample_data())
assert_true(s.valid_email.valid)
assert_false(s.invalid_email.valid)
assert_false(s.invalid_email2.valid)
assert_false(s.invalid_email3.valid)
def test_time_after(): s = Schema() s.my_birthday.date().time_after(date.today()) s.far_far_away.date(format='american_scientific').time_after(date.today()) s.long_time_ago.date(format='american_scientific').time_after(date.today()) s.validate(test_data) assert_false(s.valid) assert_false(s.my_birthday.valid) assert_true(s.far_far_away.valid) assert_false(s.long_time_ago.valid)
def test_time_after():
s = Schema()
s.my_birthday.date().time_after(date.today())
s.far_far_away.date(format='american_scientific').time_after(date.today())
s.long_time_ago.date(format='american_scientific').time_after(date.today())
s.validate(test_data)
assert_false(s.valid)
assert_false(s.my_birthday.valid)
assert_true(s.far_far_away.valid)
assert_false(s.long_time_ago.valid)
def test_integer():
s = Schema(strip_blank=False)
s.integer_value.integer()
s.float_value.integer()
s.not_integer.integer()
s.validate(test_data)
assert_false(s.valid)
assert_true(s.integer_value.valid)
assert_false(s.float_value.valid)
assert_false(s.not_integer.valid)
assert_is_instance(s.integer_value.result, int)
def test_integer():
s = Schema(strip_blank=False)
s.integer_value.integer()
s.float_value.integer()
s.not_integer.integer()
s.validate(test_data)
assert_false(s.valid)
assert_true(s.integer_value.valid)
assert_false(s.float_value.valid)
assert_false(s.not_integer.valid)
assert_is_instance(s.integer_value.result, int)
def test_date(): s = Schema() s.valid_date.date() s.valid_europe_date.date(format='europe') s.valid_europe_expanded.date(format='europe_expanded') s.invalid_date.date() s.garbage_date.date() s.validate(test_data) assert_false(s.valid) assert_true(s.valid_date.valid) assert_true(s.valid_europe_date.valid) assert_true(s.valid_europe_expanded.valid) assert_false(s.invalid_date.valid) assert_false(s.garbage_date.valid)
def test_date():
s = Schema()
s.valid_date.date()
s.valid_europe_date.date(format='europe')
s.valid_europe_expanded.date(format='europe_expanded')
s.invalid_date.date()
s.garbage_date.date()
s.validate(test_data)
assert_false(s.valid)
assert_true(s.valid_date.valid)
assert_true(s.valid_europe_date.valid)
assert_true(s.valid_europe_expanded.valid)
assert_false(s.invalid_date.valid)
assert_false(s.garbage_date.valid)
def test_field():
s = Schema()
s.some_field.require()
d = {
'some_field': 'Test Value B'
}
s.validate(d)
assert_true(s.valid)
s.reset()
assert_false(s.valid)
d = {'total_fail': 'will not work'}
s.validate(d)
assert_false(s.valid)
assert_false(s.some_field.valid)
assert_in('This field cannot be missing.', s.some_field.errors)
def test_credit_card():
s = Schema()
s.valid_visa.credit_card()
s.valid_amex.credit_card()
s.valid_mc.credit_card()
s.valid_discover.credit_card()
s.valid_other.credit_card()
s.invalid_number.credit_card()
s.invalid_date.credit_card()
s.invalid_csc.credit_card()
s.forbidden_type.credit_card(brands=['visa'])
s.expired_date.credit_card()
s.validate(test_data)
assert_false(s.valid)
assert_true(s.valid_visa.valid)
assert_true(s.valid_amex.valid)
assert_true(s.valid_mc.valid)
assert_true(s.valid_discover.valid)
assert_true(s.valid_other.valid)
assert_false(s.invalid_number.valid)
assert_false(s.invalid_date.valid)
assert_false(s.invalid_csc.valid)
assert_false(s.forbidden_type.valid)
assert_false(s.expired_date.valid)
assert_equals(s.valid_visa.result[3], u'visa')
assert_equals(s.valid_amex.result[3], u'amex')
assert_equals(s.valid_mc.result[3], u'mastercard')
assert_equals(s.valid_discover.result[3], u'discover')
assert_equals(s.valid_other.result[3], u'other')
assert_equals(s.invalid_number.errors[
0], 'The specified credit card number is not valid.')
assert_equals(s.invalid_date.errors[
0], 'Invalid expiration date format. Must be one of : [MMYY, MYY, MYYYY, MMYYYY]')
assert_equals(s.invalid_csc.errors[0], 'The CSC code is not valid.')
assert_equals(s.forbidden_type.errors[
0], 'The type amex is not an acceptable brand.')
assert_equals(s.expired_date.errors[0], 'The credit card is expired.')
def test_strictly_decreasing(self):
"""test some strictly_decreasing examples"""
assert_false(strictly_decreasing(self.two_steps['x']))
assert_false(strictly_decreasing(self.two_steps_reverse['x']))
assert_false(strictly_decreasing(self.two_ramps['x']))
ok_(strictly_decreasing(self.two_ramps_reverse['x']))
assert_false(strictly_decreasing(self.two_ramps_two_steps['x']))
assert_false(strictly_decreasing(self.two_ramps_two_steps_reverse['x']))
assert_false(strictly_decreasing(self.switch_back['x']))
assert_false(strictly_decreasing(self.switch_back_steps['x']))
def test_schema():
s = Schema()
s.blank_field
s.other_blank_field.blank(True)
s.required_field.require()
s.missing_field.require()
s.match_me.match('match_to_me', 'not_a_good_match')
s.match_to_me
s.not_a_good_match
s.validate(test_schema_data)
assert_false(s.valid)
assert_false(s.blank_field.valid)
assert_true(s.other_blank_field.valid)
assert_true(s.required_field.valid)
assert_false(s.missing_field.valid)
assert_false(s.match_me.valid)
assert_true(s.match_to_me.valid)
assert_false(s.not_a_good_match.valid)
s = Schema(match=[('password', 'password_confirm')],
require=['field_one', 'field_two'],
blank=['can_be_blank'],
strip_blank=False)
s.password
s.password_confirm
s.field_one
s.field_two
s.can_be_blank
s.validate(test_data_two)
assert_false(s.valid)
assert_false(s.password.valid)
assert_false(s.password_confirm.valid)
assert_true(s.field_one.valid)
assert_false(s.field_two.valid)
assert_true(s.can_be_blank.valid)
assert_equals(
s.results, {'field_one': 'i am required', 'can_be_blank': None})
s = Schema()
s.some_field.alt('required_field').require()
s.validate(test_required_data)
assert_true(s.valid)
s = Schema.from_dict(test_dict_schema)
s.validate(dict_schema_data)
assert_true(s.valid)
assert_equals(s.not_a_name.result, 'testing')
assert_equals(s.alt_name.result, 'testing')
def test_credit_card():
s = Schema()
s.valid_visa.credit_card()
s.valid_amex.credit_card()
s.valid_mc.credit_card()
s.valid_discover.credit_card()
s.valid_other.credit_card()
s.invalid_number.credit_card()
s.invalid_date.credit_card()
s.invalid_csc.credit_card()
s.forbidden_type.credit_card(brands=['visa'])
s.expired_date.credit_card()
s.validate(test_data)
assert_false(s.valid)
assert_true(s.valid_visa.valid)
assert_true(s.valid_amex.valid)
assert_true(s.valid_mc.valid)
assert_true(s.valid_discover.valid)
assert_true(s.valid_other.valid)
assert_false(s.invalid_number.valid)
assert_false(s.invalid_date.valid)
assert_false(s.invalid_csc.valid)
assert_false(s.forbidden_type.valid)
assert_false(s.expired_date.valid)
assert_equals(s.valid_visa.result[3], u'visa')
assert_equals(s.valid_amex.result[3], u'amex')
assert_equals(s.valid_mc.result[3], u'mastercard')
assert_equals(s.valid_discover.result[3], u'discover')
assert_equals(s.valid_other.result[3], u'other')
assert_equals(s.invalid_number.errors[0],
'The specified credit card number is not valid.')
assert_equals(
s.invalid_date.errors[0],
'Invalid expiration date format. Must be one of : [MMYY, MYY, MYYYY, MMYYYY]'
)
assert_equals(s.invalid_csc.errors[0], 'The CSC code is not valid.')
assert_equals(s.forbidden_type.errors[0],
'The type amex is not an acceptable brand.')
assert_equals(s.expired_date.errors[0], 'The credit card is expired.')
def test_strictly_decreasing(self):
"""test some strictly_decreasing examples"""
assert_false(strictly_decreasing(self.two_steps['x']))
assert_false(strictly_decreasing(self.two_steps_reverse['x']))
assert_false(strictly_decreasing(self.two_ramps['x']))
ok_(strictly_decreasing(self.two_ramps_reverse['x']))
assert_false(strictly_decreasing(self.two_ramps_two_steps['x']))
assert_false(strictly_decreasing(
self.two_ramps_two_steps_reverse['x']))
assert_false(strictly_decreasing(self.switch_back['x']))
assert_false(strictly_decreasing(self.switch_back_steps['x']))
