Changeset 137

Show
Ignore:
Timestamp:
11/06/07 00:39:11
Author:
thejimmyg
Message:

Added an SQLAlchemy 0.4 driver which uses the (as yet unreleased) SQLAlchemyManager middleware

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • AuthKit/trunk/examples/user/database/README.txt

    r67 r137  
    11To use this example do the following: 
    22 
    3 1. Edit ``model.py`` to choose the database you wish to use. 
     31. Edit ``app.py`` to choose the database you wish to use. 
    44   The default should be fine but you will need ``pysqlite`` installed. 
    55    
    6 2. Run the ``create.py`` file to create the necessary database tables:: 
    7  
    8         python create.py 
    9  
    10 3. Start the example server:: 
     62. Start the example server (this will create the database and setup the 
     7   user information):: 
    118 
    129        python app.py 
    1310         
    14 4. Visit the server at http://localhost:8080/private 
     113. Visit the server at http://localhost:8080/private 
     12 
     134. Delete the test.db file if you want to test the example again. 
     14 
     15The usernames and passwords are set up in the app.py file. 
  • AuthKit/trunk/examples/user/database/app.py

    r71 r137  
    1616from authkit.authenticate import middleware 
    1717from authkit.authorize import authorize 
    18 from authkit.users.sqlalchemy_driver import UsersFromDatabase 
    1918from authkit.permissions import ValidAuthKitUser, HasAuthKitRole, HasAuthKitGroup 
    2019 
     
    7170        return self._access_granted(start_response, "You are in the <tt>pylons</tt> group.") 
    7271 
     72from jimmyg.database.sa import SQLAlchemyManager 
     73import authkit.users.sqlalchemy_04_driver 
     74import os 
     75# os.remove('test.db') 
     76 
    7377app = SampleApp() 
    74 # Not needed, included by the authenticate middleware 
    75 #app = HTTPExceptionHandler(app) 
    7678app = middleware( 
    7779    app, 
    7880    setup_method='form,cookie', 
    7981    cookie_secret='secret encryption string', 
    80     form_authenticate_user_type = "authkit.users.sqlalchemy_driver:UsersFromDatabase", 
    81     form_authenticate_user_data = "model", 
     82    form_authenticate_user_type = "authkit.users.sqlalchemy_04_driver:UsersFromDatabase", 
    8283    cookie_signoutpath = '/signout', 
    8384    # setup_intercept = "401, 403", 
    8485) 
     86app = SQLAlchemyManager(app, {'sqlalchemy.url':'sqlite:///test.db'}, [authkit.users.sqlalchemy_04_driver.setup_model]) 
     87app.create_all() 
     88connection = app.engine.connect() 
     89session = app.session_maker(bind=connection) 
     90try: 
     91    environ = {} 
     92    environ['sqlalchemy.session'] = session 
     93    environ['sqlalchemy.model'] = app.model 
     94    users = authkit.users.sqlalchemy_04_driver.UsersFromDatabase(environ) 
     95    users.group_create("pylons") 
     96    users.role_create("admin") 
     97    users.user_create("james", password="password1", group="pylons") 
     98    users.user_create("ben", password="password2") 
     99    users.user_add_role("ben", role="admin") 
     100    session.flush() 
     101    session.commit() 
     102finally: 
     103    session.close() 
     104    connection.close() 
     105 
    85106app = HTTPExceptionHandler(app) 
    86107if __name__ == '__main__': 
  • AuthKit/trunk/test/test.py

    r119 r137  
    8989    app = middleware( 
    9090        sample_app, 
    91         setup_method='form,cookie', 
    92         cookie_secret='secret encryption string', 
    93         form_authenticate_user_data = """ 
     91        setup_method='digest', 
     92        digest_realm='test', 
     93        digest_authenticate_user_data = """ 
    9494            Username1:password1 
    9595            username2:password2 
     
    9999    ) 
    100100    res = TestApp(app).get('/403', status=401) 
    101     assertEqual(res.header('content-type'), 'text/html') 
     101    assertEqual(res.header('content-type'), 'text/plain') 
    102102    # XXX Should this keep the original status code or not? 
    103103    assertEqual(res.full_status, '401 Unauthorized') 
    104     assert 'Please Sign In' in res 
     104    assert 'This server could not verify that you are authorized' in res 
    105105 
    106106    res = TestApp(app).get('/702', status=401) 
    107     assertEqual(res.header('content-type'), 'text/html') 
     107    assertEqual(res.header('content-type'), 'text/plain') 
    108108    # XXX Should this keep the original status code or not? 
    109109    assertEqual(res.full_status, '401 Unauthorized') 
    110     assert 'Please Sign In' in res 
     110    assert 'This server could not verify that you are authorized' in res 
    111111 
    112112    res = TestApp(app).get('/500', status=500) 
     
    129129 
    130130def test_form_fail(): 
    131     res = TestApp(form_app).get('/private', status=401
     131    res = TestApp(form_app).get('/private', status=200
    132132    assertEqual(res.header('content-type'),'text/html; charset=UTF-8') 
    133     assertEqual(res.full_status, '401 Unauthorized') 
     133    assertEqual(res.full_status, '200 OK') 
    134134    assert 'Please Sign In' in res 
    135135 
     
    155155def test_users_api_database(): 
    156156    try:  
    157         from authkit.users.sqlalchemy_driver import UsersFromDatabase 
     157        from authkit.users.sqlalchemy_04_driver import UsersFromDatabase, setup_model 
    158158    except ImportError: 
    159159        raise Exception("Could not run the SQLAlchemy tests, not installed") 
    160     if os.path.exists("test/mydb.db"): 
    161         os.remove("test/mydb.db") 
    162     import model as test_model 
    163      
    164     d = UsersFromDatabase(test_model) 
    165      
    166     test_model.meta.create_all(test_model.engine) 
    167      
    168     d.role_create("wiki") 
    169     d.role_create("adMin") 
    170     d.role_create("editor") 
    171     d.group_create("pyLOns") 
    172     d.group_create("dJAngo") 
    173     d.user_create("jaMEs", "passWOrd1", "pyLoNs") 
    174     d.user_create("ben", "password2") 
    175     d.user_create("Simon", "password3") 
    176     d.user_create("ian", "paSsword4") 
    177     assertEqual(d.list_roles(),["admin", "editor", "wiki"]) 
    178     assertEqual(d.list_groups(),["django", "pylons"]) 
    179     assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon']) 
    180     assertEqual(d.user_has_password("james", "passWOrd1"), True) 
    181     assertEqual(d.user_has_password("james", "password1"), False) 
    182      
    183     d.role_create("test_role") 
    184     d.group_create("test_group") 
    185     d.user_create("test_user", "password") 
    186     assertEqual(d.list_roles(),["admin", "editor", "test_role", "wiki"]) 
    187     assertEqual(d.list_groups(),["django", "pylons", "test_group"]) 
    188     assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon', "test_user"]) 
    189     d.role_delete("test_role") 
    190     d.group_delete("test_group") 
    191     d.user_delete("test_user") 
    192     assertEqual(d.list_roles(),["admin", "editor", "wiki"]) 
    193     assertEqual(d.list_groups(),["django", "pylons"]) 
    194     assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon']) 
    195  
    196     assertEqual(d.user_has_role("james", "admin"), False) 
    197     d.user_add_role("james", "admin") 
    198     assertEqual(d.user_has_role("james", "admin"), True) 
    199     d.user_remove_role("james", "admin") 
    200     assertEqual(d.user_has_role("james", "admin"), False) 
    201  
    202     d.user_add_role("james", "wiki") 
    203     d.user_add_role("simon", "wiki") 
    204     d.user_add_role("james", "admin") 
    205     #d.user_add_role("james", "editor") 
    206     d.user_add_role("ben", "editor") 
    207      
    208     assertEqual(d.user_has_group("james", "pylons"), True) 
    209     assertEqual(d.user_has_group("simon", None), True) 
    210     assertEqual(d.user_has_group("simon", "django"), False) 
    211     d.user_set_group("simon", "dJangO") 
    212     assertEqual(d.user_has_group("simon", None), False) 
    213     d.user_set_group("bEn", "PyLONS") 
    214     assertEqual(d.user_has_group("simon", "django"), True) 
    215     assertEqual(d.user_has_group("bEn", "pYlons"), True) 
    216     d.user_remove_group("bEn") 
    217     assertEqual(d.user_has_group("bEn", "pYlons"), False) 
    218     d.user_set_group("bEn", "PyLONS") 
    219     assertEqual(d.user_has_group("bEn", "pYlons"), True) 
    220      
    221     assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon']) 
    222     d.user_set_username("james", "jim") 
    223     assertEqual(d.list_users(),['ben', 'ian', 'jim', 'simon']) 
    224     d.user_set_username("jim", "james") 
    225      
    226     from authkit.users import UsersFromFile, UsersFromString, AuthKitNoSuchUserError, AuthKitNoSuchGroupError,AuthKitNoSuchRoleError 
    227     string_data = """jaMEs:passWOrd1:pyLOns wiki adMin 
    228     ben:password2:pylons admin editor 
    229     simon:password3:dJAngo 
    230     ian:paSsword4 wiki 
    231     """ 
    232     filename = 'test/user_file_data.txt' 
    233      
    234     s = UsersFromString(string_data) 
    235     f = UsersFromFile(filename) 
    236  
    237     # Test Parsing 
    238     assertAllEqual( 
    239         s.passwords, 
    240         f.passwords, 
    241         { 
    242             'james':'passWOrd1', 
    243             'ben':'password2', 
    244             'simon':'password3', 
    245             'ian':'paSsword4', 
    246         }, 
     160    try:  
     161        from jimmyg.database.sa import SQLAlchemyManager 
     162    except ImportError: 
     163        raise Exception("Could not run the SQLAlchemy tests, the jimmyg module containing the SQLAlchemyManager is not installed") 
     164    if os.path.exists("mydb.db"): 
     165        os.remove("mydb.db") 
     166 
     167    app = SQLAlchemyManager( 
     168        None,  
     169        {'sqlalchemy.url':'sqlite:///mydb.db'},  
     170        [setup_model] 
    247171    ) 
    248     assertAllEqual( 
    249         s.roles,  
    250         f.roles, 
    251         { 
    252             'james':['admin', 'wiki'], 
    253             'ben':['admin','editor'], 
    254             'ian':['wiki'], 
    255             'simon':[], 
    256         }, 
    257     ) 
    258     assertAllEqual( 
    259         s.groups,  
    260         f.groups, 
    261         { 
    262             'james':'pylons', 
    263             'ben':'pylons', 
    264             'ian': None, 
    265             'simon':'django', 
    266         }, 
    267     ) 
    268     assertAllEqual( 
    269         s.usernames,  
    270         f.usernames, 
    271         ['ben', 'ian', 'james', 'simon'], 
    272     ) 
    273  
    274     # Test list functions 
    275     assertAllEqual( 
    276         s.list_users(), 
    277         f.list_users(), 
    278         d.list_users(), 
    279         ['ben', 'ian', 'james', 'simon'], 
    280     ) 
    281     assertAllEqual( 
    282         s.list_roles(),  
    283         f.list_roles(), 
    284         d.list_roles(), 
    285         ['admin', 'editor', 'wiki'], 
    286     ) 
    287     assertAllEqual( 
    288         s.list_groups(),  
    289         f.list_groups(), 
    290         d.list_groups(), 
    291         ['django','pylons'], 
    292     ) 
    293  
    294     # Test user has functions 
    295     assertAllEqual( 
    296         s.user_has_role('jAMes','WiKi'),  
    297         f.user_has_role('jAMes','WiKi'),  
    298         d.user_has_role('jAMes','WiKi'),  
    299         True 
    300     ) 
    301     assertAllEqual( 
    302         s.user_has_role('jAMes','editOr'),  
    303         f.user_has_role('jAMes','editOr'),  
    304         d.user_has_role('jAMes','editOr'),  
    305         False 
    306     ) 
    307      
    308     assertAllEqual( 
    309         s.user_has_group('jAMeS','PyLons'),  
    310         f.user_has_group('jAMes','pylOns'),  
    311         d.user_has_group('jAMes','pylOns'),  
    312         True 
    313     ) 
    314     assertAllEqual( 
    315         s.user_has_group('jameS','djaNgo'),  
    316         f.user_has_group('JAMes','djAngo'),  
    317         d.user_has_group('JAMes','djAngo'),  
    318         False 
    319     ) 
    320  
    321     assertAllEqual( 
    322         s.user_has_password('jAMeS','passWOrd1'),  
    323         f.user_has_password('jAMes','passWOrd1'),  
    324         d.user_has_password('jAMes','passWOrd1'),  
    325         True 
    326     ) 
    327     assertAllEqual( 
    328         s.user_has_password('jameS','PASSWORD1'),  
    329         f.user_has_password('JAMes','PASSWORD1'),  
    330         d.user_has_password('JAMes','PASSWORD1'),  
    331         False 
    332     ) 
    333  
    334     # Existence Methods 
    335     assertAllEqual( 
    336         s.user_exists('jAMeS'),  
    337         f.user_exists('jAMes'),  
    338         d.user_exists('jAMes'),  
    339         True 
    340     ) 
    341     assertAllEqual( 
    342         s.user_exists('nobody'),  
    343         f.user_exists('nobody'),  
    344         d.user_exists('nobody'),  
    345         False 
    346     ) 
    347      
    348     # Existence Methods 
    349     assertAllEqual( 
    350         s.role_exists('wiKi'),  
    351         f.role_exists('Wiki'),  
    352         d.role_exists('Wiki'),  
    353         True 
    354     ) 
    355     assertAllEqual( 
    356         s.role_exists('norole'),  
    357         f.role_exists('norole'),  
    358         d.role_exists('norole'),  
    359         False 
    360     ) 
    361      
    362     assertAllEqual( 
    363         s.group_exists('pyLons'),  
    364         f.group_exists('PYlons'),  
    365         d.group_exists('PYlons'),  
    366         True 
    367     ) 
    368     assertAllEqual( 
    369         s.group_exists('nogroup'),  
    370         f.group_exists('nogroup'),  
    371         d.group_exists('nogroup'),  
    372         False 
    373     ) 
    374  
    375  
    376     # User Methods 
    377      
    378     assertAllEqual( 
    379         s.user('James'),  
    380         f.user('James'), 
    381         d.user('James'), 
    382         { 
    383             'username': 'james', 
    384             'group':    'pylons', 
    385             'password': 'passWOrd1', 
    386             'roles':    ['admin','wiki'], 
    387         } 
    388     ) 
    389      
    390     # Test all user methods raise: 
    391     for plugin in [s,f,d]: 
    392         for func in [ 
    393             'user', 
    394             'user_roles', 
    395             'user_group', 
    396             'user_password', 
    397         ]: 
    398             try: 
    399                 getattr(plugin, func)('nouser') 
    400             except AuthKitNoSuchUserError, e: 
    401                 pass 
    402             else: 
    403                 raise AssertionError("Failed to throw a no user error") 
    404     for plugin in [s,f,d]: 
    405         for func in [ 
    406             'user_has_password', 
    407             'user_has_role', 
    408             'user_has_group', 
    409         ]: 
    410             try: 
    411                 getattr(plugin, func)('nouser','somevar') 
    412             except AuthKitNoSuchUserError, e: 
    413                 pass 
    414             else: 
    415                 raise AssertionError("Failed to throw a no user error") 
    416  
    417     assertAllEqual( 
    418         s.user_roles('James'),  
    419         f.user_roles('James'), 
    420         d.user_roles('James'), 
    421         ['admin','wiki'] 
    422     ) 
    423     assertAllEqual( 
    424         s.user_group('James'),  
    425         f.user_group('James'), 
    426         d.user_group('James'), 
    427         'pylons' 
    428     ) 
    429     assertAllEqual( 
    430         s.user_password('James'),  
    431         f.user_password('James'), 
    432         d.user_password('James'), 
    433         'passWOrd1' 
    434     ) 
    435          
    436          
    437          
     172    app.create_all() 
     173    connection = app.engine.connect() 
     174    session = app.session_maker(bind=connection) 
     175    try: 
     176        environ = {} 
     177        environ['sqlalchemy.session'] = session 
     178        environ['sqlalchemy.model'] = app.model 
     179        d = UsersFromDatabase(environ) 
     180        d.role_create("wiki") 
     181        d.role_create("adMin") 
     182        d.role_create("editor") 
     183        d.group_create("pyLOns") 
     184        d.group_create("dJAngo") 
     185        d.user_create("jaMEs", "passWOrd1", "pyLoNs") 
     186        d.user_create("ben", "password2") 
     187        d.user_create("Simon", "password3") 
     188        d.user_create("ian", "paSsword4") 
     189        assertEqual(d.list_roles(),["admin", "editor", "wiki"]) 
     190        assertEqual(d.list_groups(),["django", "pylons"]) 
     191        assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon']) 
     192        assertEqual(d.user_has_password("james", "passWOrd1"), True) 
     193        assertEqual(d.user_has_password("james", "password1"), False) 
     194         
     195        d.role_create("test_role") 
     196        d.group_create("test_group") 
     197        d.user_create("test_user", "password") 
     198        assertEqual(d.list_roles(),["admin", "editor", "test_role", "wiki"]) 
     199        assertEqual(d.list_groups(),["django", "pylons", "test_group"]) 
     200        assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon', "test_user"]) 
     201        d.role_delete("test_role") 
     202        d.group_delete("test_group") 
     203        d.user_delete("test_user") 
     204        assertEqual(d.list_roles(),["admin", "editor", "wiki"]) 
     205        assertEqual(d.list_groups(),["django", "pylons"]) 
     206        assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon']) 
     207     
     208        assertEqual(d.user_has_role("james", "admin"), False) 
     209        d.user_add_role("james", "admin") 
     210        assertEqual(d.user_has_role("james", "admin"), True) 
     211        d.user_remove_role("james", "admin") 
     212        assertEqual(d.user_has_role("james", "admin"), False) 
     213     
     214        d.user_add_role("james", "wiki") 
     215        d.user_add_role("simon", "wiki") 
     216        d.user_add_role("james", "admin") 
     217        #d.user_add_role("james", "editor") 
     218        d.user_add_role("ben", "editor") 
     219         
     220        assertEqual(d.user_has_group("james", "pylons"), True) 
     221        assertEqual(d.user_has_group("simon", None), True) 
     222        assertEqual(d.user_has_group("simon", "django"), False) 
     223        d.user_set_group("simon", "dJangO") 
     224        assertEqual(d.user_has_group("simon", None), False) 
     225        d.user_set_group("bEn", "PyLONS") 
     226        assertEqual(d.user_has_group("simon", "django"), True) 
     227        assertEqual(d.user_has_group("bEn", "pYlons"), True) 
     228        d.user_remove_group("bEn") 
     229        assertEqual(d.user_has_group("bEn", "pYlons"), False) 
     230        d.user_set_group("bEn", "PyLONS") 
     231        assertEqual(d.user_has_group("bEn", "pYlons"), True) 
     232         
     233        assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon']) 
     234        d.user_set_username("james", "jim") 
     235        assertEqual(d.list_users(),['ben', 'ian', 'jim', 'simon']) 
     236        d.user_set_username("jim", "james") 
     237         
     238        from authkit.users import UsersFromFile, UsersFromString, AuthKitNoSuchUserError, AuthKitNoSuchGroupError,AuthKitNoSuchRoleError 
     239        string_data = """jaMEs:passWOrd1:pyLOns wiki adMin 
     240        ben:password2:pylons admin editor 
     241        simon:password3:dJAngo 
     242        ian:paSsword4 wiki 
     243        """ 
     244        filename = 'test/user_file_data.txt' 
     245         
     246        s = UsersFromString(string_data) 
     247        f = UsersFromFile(filename) 
     248     
     249        # Test Parsing 
     250        assertAllEqual( 
     251            s.passwords, 
     252            f.passwords, 
     253            { 
     254                'james':'passWOrd1', 
     255                'ben':'password2', 
     256                'simon':'password3', 
     257                'ian':'paSsword4', 
     258            }, 
     259        ) 
     260        assertAllEqual( 
     261            s.roles,  
     262            f.roles, 
     263            { 
     264                'james':['admin', 'wiki'], 
     265                'ben':['admin','editor'], 
     266                'ian':['wiki'], 
     267                'simon':[], 
     268            }, 
     269        ) 
     270        assertAllEqual( 
     271            s.groups,  
     272            f.groups, 
     273            { 
     274                'james':'pylons', 
     275                'ben':'pylons', 
     276                'ian': None, 
     277                'simon':'django', 
     278            }, 
     279        ) 
     280        assertAllEqual( 
     281            s.usernames,  
     282            f.usernames, 
     283            ['ben', 'ian', 'james', 'simon'], 
     284        ) 
     285     
     286        # Test list functions 
     287        assertAllEqual( 
     288            s.list_users(), 
     289            f.list_users(), 
     290            d.list_users(), 
     291            ['ben', 'ian', 'james', 'simon'], 
     292        ) 
     293        assertAllEqual( 
     294            s.list_roles(),  
     295            f.list_roles(), 
     296            d.list_roles(), 
     297            ['admin', 'editor', 'wiki'], 
     298        ) 
     299        assertAllEqual( 
     300            s.list_groups(),  
     301            f.list_groups(), 
     302            d.list_groups(), 
     303            ['django','pylons'], 
     304        ) 
     305     
     306        # Test user has functions 
     307        assertAllEqual( 
     308            s.user_has_role('jAMes','WiKi'),  
     309            f.user_has_role('jAMes','WiKi'),  
     310            d.user_has_role('jAMes','WiKi'),  
     311            True 
     312        ) 
     313        assertAllEqual( 
     314            s.user_has_role('jAMes','editOr'),  
     315            f.user_has_role('jAMes','editOr'),  
     316            d.user_has_role('jAMes','editOr'),  
     317            False 
     318        ) 
     319         
     320        assertAllEqual( 
     321            s.user_has_group('jAMeS','PyLons'),  
     322            f.user_has_group('jAMes','pylOns'),  
     323            d.user_has_group('jAMes','pylOns'),  
     324            True 
     325        ) 
     326        assertAllEqual( 
     327            s.user_has_group('jameS','djaNgo'),  
     328            f.user_has_group('JAMes','djAngo'),  
     329            d.user_has_group('JAMes','djAngo'),  
     330            False 
     331        ) 
     332     
     333        assertAllEqual( 
     334            s.user_has_password('jAMeS','passWOrd1'),  
     335            f.user_has_password('jAMes','passWOrd1'),  
     336            d.user_has_password('jAMes','passWOrd1'),  
     337            True 
     338        ) 
     339        assertAllEqual( 
     340            s.user_has_password('jameS','PASSWORD1'),  
     341            f.user_has_password('JAMes','PASSWORD1'),  
     342            d.user_has_password('JAMes','PASSWORD1'),  
     343            False 
     344        ) 
     345     
     346        # Existence Methods 
     347        assertAllEqual( 
     348            s.user_exists('jAMeS'),  
     349            f.user_exists('jAMes'),  
     350            d.user_exists('jAMes'),  
     351            True 
     352        ) 
     353        assertAllEqual( 
     354            s.user_exists('nobody'),  
     355            f.user_exists('nobody'),  
     356            d.user_exists('nobody'),  
     357            False 
     358        ) 
     359         
     360        # Existence Methods 
     361        assertAllEqual( 
     362            s.role_exists('wiKi'),  
     363            f.role_exists('Wiki'),  
     364            d.role_exists('Wiki'),  
     365            True 
     366        ) 
     367        assertAllEqual( 
     368            s.role_exists('norole'),  
     369            f.role_exists('norole'),  
     370            d.role_exists('norole'),  
     371            False 
     372        ) 
     373         
     374        assertAllEqual( 
     375            s.group_exists('pyLons'),  
     376            f.group_exists('PYlons'),  
     377            d.group_exists('PYlons'),  
     378            True 
     379        ) 
     380        assertAllEqual( 
     381            s.group_exists('nogroup'),  
     382            f.group_exists('nogroup'),  
     383            d.group_exists('nogroup'),  
     384            False 
     385        ) 
     386     
     387     
     388        # User Methods 
     389         
     390        assertAllEqual( 
     391            s.user('James'),  
     392            f.user('James'), 
     393            d.user('James'), 
     394            { 
     395                'username': 'james', 
     396                'group':    'pylons', 
     397                'password': 'passWOrd1', 
     398                'roles':    ['admin','wiki'], 
     399            } 
     400        ) 
     401         
     402        # Test all user methods raise: 
     403        for plugin in [s,f,d]: 
     404            for func in [ 
     405                'user', 
     406                'user_roles', 
     407                'user_group', 
     408                'user_password', 
     409            ]: 
     410                try: 
     411                    getattr(plugin, func)('nouser') 
     412                except AuthKitNoSuchUserError, e: 
     413                    pass 
     414                else: 
     415                    raise AssertionError("Failed to throw a no user error") 
     416        for plugin in [s,f,d]: 
     417            for func in [ 
     418                'user_has_password', 
     419                'user_has_role', 
     420                'user_has_group', 
     421            ]: 
     422                try: 
     423                    getattr(plugin, func)('nouser','somevar') 
     424                except AuthKitNoSuchUserError, e: 
     425                    pass 
     426                else: 
     427                    raise AssertionError("Failed to throw a no user error") 
     428     
     429        assertAllEqual( 
     430            s.user_roles('James'),  
     431            f.user_roles('James'), 
     432            d.user_roles('James'), 
     433            ['admin','wiki'] 
     434        ) 
     435        assertAllEqual( 
     436            s.user_group('James'),  
     437            f.user_group('James'), 
     438            d.user_group('James'), 
     439            'pylons' 
     440        ) 
     441        assertAllEqual( 
     442            s.user_password('James'),  
     443            f.user_password('James'), 
     444            d.user_password('James'), 
     445            'passWOrd1' 
     446        ) 
     447         
     448        session.flush() 
     449        session.commit() 
     450    finally: 
     451        session.close() 
     452        connection.close() 
     453 
     454