def test_inject():
em, app = _setup()
em.enable_xhr(app)
em.enable_injection(app)
em.add_injectable(InjectableClass)
with app.test_client() as c:
r = c.get('/inject/joe-slug')
assert_in('joe-slug', r.data)
r = c.get('/inject-as-arg/joe-slug')
assert_in('joe-slug', r.data)
with assert_raises(RuntimeError):
r = c.get('/inject-non-injectable/here-comes-an-error')
em.add_injectable(NonInjectableClass)
with assert_raises(RuntimeError):
r = c.get('/inject-non-injectable/still-going-to-fail')
with assert_raises(AttributeError):
r = c.get('/inject-skip-by-default')
r = c.get('/inject-list-denoting/apples')
assert_equals(r.status_code, 200)
def test_upper():
s = Schema()
s.lower_case.upper()
s.validate(_sample_data())
assert_true(s.valid)
assert_equals(s.lower_case.result, 'I AM THE QUIET MOUSE')
def test_assetman():
a = Assetman(TEST_KEY, TEST_SECRET, TEST_BUCKET)
assert_is_none(a._connection)
ctx = a.connection
assert_is_instance(ctx, S3Connection)
''' Simple Asset '''
asset = Asset('my sweet data')
a.save_asset(asset)
assert_is_not_none(asset.uuid)
retrieved = a.get_asset(asset.uuid)
assert_equals(asset.uuid, retrieved.uuid)
a.delete_asset(asset.uuid)
assert_is_none(a.get_asset(asset.uuid))
''' Prefixed Asset '''
asset = Asset('My Prefixed Data', prefix='mah_prefix/bro')
a.save_asset(asset)
assert_is_not_none(asset.uuid)
retrieved = a.get_asset(asset.uuid, asset.prefix)
assert_equals(asset.uuid, retrieved.uuid)
a.delete_asset(asset.uuid, asset.prefix)
assert_is_none(a.get_asset(asset.uuid, asset.prefix))
def test_lower():
s = Schema()
s.upper_case.lower()
s.validate(_sample_data())
assert_true(s.valid)
assert_equals(s.upper_case.result, 'i am the rawrmachine')
def test_removespaces():
s = Schema()
s.awkward_spaces.removespaces()
s.validate(_sample_data())
assert_true(s.valid)
assert_equals(s.awkward_spaces.result, 'openthedoorgetonthefloorrr')
def test_removespaces():
s = Schema()
s.awkward_spaces.removespaces()
s.validate(_sample_data())
assert_true(s.valid)
assert_equals(s.awkward_spaces.result, 'openthedoorgetonthefloorrr')
def test_lower():
s = Schema()
s.upper_case.lower()
s.validate(_sample_data())
assert_true(s.valid)
assert_equals(s.upper_case.result, 'i am the rawrmachine')
def test_strip():
s = Schema()
s.flanking_spaces.strip()
s.validate(_sample_data())
assert_true(s.valid)
assert_equals(s.flanking_spaces.result, 'everybody walk the dinosaur')
def test_upper():
s = Schema()
s.lower_case.upper()
s.validate(_sample_data())
assert_true(s.valid)
assert_equals(s.lower_case.result, 'I AM THE QUIET MOUSE')
def reading_fxn(cls, **kwargs):
assert_equals(cls, CRUDMan)
assert_in('name', kwargs.keys())
if kwargs.get('_many'):
return 'Many things'
return 'Something'
def test_strip():
s = Schema()
s.flanking_spaces.strip()
s.validate(_sample_data())
assert_true(s.valid)
assert_equals(s.flanking_spaces.result, 'everybody walk the dinosaur')
def test_inject():
em, app = _setup()
em.enable_xhr(app)
em.enable_injection(app)
em.add_injectable(InjectableClass)
with app.test_client() as c:
r = c.get('/inject/joe-slug')
assert_in('joe-slug', r.data)
r = c.get('/inject-as-arg/joe-slug')
assert_in('joe-slug', r.data)
with assert_raises(RuntimeError):
r = c.get('/inject-non-injectable/here-comes-an-error')
em.add_injectable(NonInjectableClass)
with assert_raises(RuntimeError):
r = c.get('/inject-non-injectable/still-going-to-fail')
with assert_raises(AttributeError):
r = c.get('/inject-skip-by-default')
r = c.get('/inject-list-denoting/apples')
assert_equals(r.status_code, 200)
def test_drop_keys():
s = Schema()
s.some_dict.drop_keys('one', 'two')
s.validate(test_data)
assert_true(s.valid)
assert_equals(s.some_dict.result, {'red': 'fish', 'blue': 'fish'})
def test_boolean():
s = Schema(blank='all')
s.true_value.boolean()
s.false_value.boolean()
s.validate(test_data)
assert_true(s.valid)
assert_true(s.true_value.result)
assert_equals(s.false_value.result, False)
def test_constant():
s = Schema()
s.some_cst_value.constant('blue apple')
s.validate({'some_cst_value': 'Roger that'})
assert_true(s.valid)
assert_equals(s.some_cst_value.result, 'blue apple')
def test_drop_keys():
s = Schema()
s.some_dict.drop_keys('one', 'two')
s.validate(test_data)
assert_true(s.valid)
assert_equals(s.some_dict.result, {'red': 'fish', 'blue': 'fish'})
def test_boolean():
s = Schema(blank='all')
s.true_value.boolean()
s.false_value.boolean()
s.validate(test_data)
assert_true(s.valid)
assert_true(s.true_value.result)
assert_equals(s.false_value.result, False)
def test_canonize():
s = Schema()
s.noncanonical_string.canonize()
s.validate(_sample_data())
assert_true(s.valid)
assert_equals(s.noncanonical_string.result,
u'there_is_nothing_canonical_aboutmeeeeee333_see?')
def test_canonize():
s = Schema()
s.noncanonical_string.canonize()
s.validate(_sample_data())
assert_true(s.valid)
assert_equals(s.noncanonical_string.result,
u'there_is_nothing_canonical_aboutmeeeeee333_see?')
def test_update():
data_dict = {'name': 'CRUD Woman', 'catch_phrase': 'Cant change this'}
@object_updated.connect
def updating_fxn(cls, o, **kwargs):
assert_equals(o.name, 'CRUD Man')
assert_equals(o.catch_phrase, 'I am CRUD Man. Fear my power.')
return o
o = CRUDMan.create()
r = CRUDMan.update(o, **data_dict)
assert_equals(r.name, 'CRUD Man')
def test_read():
@object_read.connect
def reading_fxn(cls, **kwargs):
assert_equals(cls, CRUDMan)
assert_in('name', kwargs.keys())
if kwargs.get('_many'):
return 'Many things'
return 'Something'
r = CRUDMan.read(name='CRUD Man')
assert_equals(r, 'Something')
r = CRUDMan.read_many(name='CRUD Man')
assert_equals(r, 'Many things')
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_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_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_slugify():
s = Schema()
s.notslugified.slugify()
s.alsonotslugified.slugify()
s.sluggingindempotency.slugify()
s.validate(_sample_data())
assert_true(s.valid)
assert_equals(s.notslugified.result,
u'i-am-not-slugified-omg-punctu3232ation-who-submits-data-like-this-anyway')
assert_equals(s.alsonotslugified.result, u'a-use-slasshes-and-stufff-32')
assert_equals(s.sluggingindempotency.result, u'already-slugged')
def test_slugify():
s = Schema()
s.notslugified.slugify()
s.alsonotslugified.slugify()
s.sluggingindempotency.slugify()
s.validate(_sample_data())
assert_true(s.valid)
assert_equals(
s.notslugified.result,
u'i-am-not-slugified-omg-punctu3232ation-who-submits-data-like-this-anyway'
)
assert_equals(s.alsonotslugified.result, u'a-use-slasshes-and-stufff-32')
assert_equals(s.sluggingindempotency.result, u'already-slugged')
def test_xhr_api():
em, app = _setup()
em.enable_xhr(app)
with app.test_client() as c:
r = c.get('/')
assert_in('I am the index page', r.data)
r = c.get('/xhr', headers=[('X-Requested-With', 'XMLHttpRequest')])
py_data = loads(r.data)
assert_in('data', py_data.keys())
assert_in('messages', py_data.keys())
assert_equals(len(py_data['data']), 2)
assert_equals(len(py_data['messages']), 5)
r = c.get('/xhr-failure')
py_data = loads(r.data)
assert_in('error', py_data.keys())
r = c.get('/xhr-failure',
headers=[('X-Requested-With', 'XMLHttpRequest')])
py_data = loads(r.data)
assert_in('error', py_data.keys())
r = c.get('/xhr-failure-with-code',
headers=[('X-Requested-With', 'XMLHttpRequest')])
assert_equals(r.status_code, 500)
py_data = loads(r.data)
assert_in('error', py_data.keys())
assert_in('code', py_data.keys())
r = c.get('/xhr-that-allows-regular-http')
py_data = loads(r.data)
assert_in('test', py_data['data'].keys())
assert_in('A message in a bottle.', py_data['messages'][0])
def test_xhr_api():
em, app = _setup()
em.enable_xhr(app)
with app.test_client() as c:
r = c.get('/')
assert_in('I am the index page', r.data)
r = c.get('/xhr', headers=[('X-Requested-With', 'XMLHttpRequest')])
py_data = loads(r.data)
assert_in('data', py_data.keys())
assert_in('messages', py_data.keys())
assert_equals(len(py_data['data']), 2)
assert_equals(len(py_data['messages']), 5)
r = c.get('/xhr-failure')
py_data = loads(r.data)
assert_in('error', py_data.keys())
r = c.get('/xhr-failure', headers=[
('X-Requested-With', 'XMLHttpRequest')])
py_data = loads(r.data)
assert_in('error', py_data.keys())
r = c.get('/xhr-failure-with-code', headers=[
('X-Requested-With', 'XMLHttpRequest')])
assert_equals(r.status_code, 500)
py_data = loads(r.data)
assert_in('error', py_data.keys())
assert_in('code', py_data.keys())
r = c.get('/xhr-that-allows-regular-http')
py_data = loads(r.data)
assert_in('test', py_data['data'].keys())
assert_in('A message in a bottle.', py_data['messages'][0])
def updating_fxn(cls, o, **kwargs):
assert_equals(o.name, 'CRUD Man')
assert_equals(o.catch_phrase, 'I am CRUD Man. Fear my power.')
return o
def delete_fxn(cls, o, **kwargs):
assert_equals(o.name, 'Dying CRUD Man')
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_strbool():
s = Schema(blank='all', strip_blank=False)
s.true_value.strbool()
s.str_false_1.strbool()
s.str_false_2.strbool()
s.str_false_3.strbool()
s.str_false_4.strbool()
s.str_false_5.strbool()
s.str_false_6.strbool()
s.validate(test_data)
assert_true(s.valid)
assert_true(s.true_value.result)
assert_equals(s.str_false_1.result, False)
assert_equals(s.str_false_2.result, False)
assert_equals(s.str_false_3.result, False)
assert_equals(s.str_false_4.result, False)
assert_equals(s.str_false_5.result, False)
assert_equals(s.str_false_6.result, False)
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_strbool():
s = Schema(blank='all', strip_blank=False)
s.true_value.strbool()
s.str_false_1.strbool()
s.str_false_2.strbool()
s.str_false_3.strbool()
s.str_false_4.strbool()
s.str_false_5.strbool()
s.str_false_6.strbool()
s.validate(test_data)
assert_true(s.valid)
assert_true(s.true_value.result)
assert_equals(s.str_false_1.result, False)
assert_equals(s.str_false_2.result, False)
assert_equals(s.str_false_3.result, False)
assert_equals(s.str_false_4.result, False)
assert_equals(s.str_false_5.result, False)
assert_equals(s.str_false_6.result, False)
