| 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] |
|---|
| 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 | |
|---|