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_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 reading_fxn(cls, **kwargs): assert_equals(cls, CRUDMan) assert_in('name', kwargs.keys()) if kwargs.get('_many'): return 'Many things' return 'Something'
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_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_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.')