def setup_config(command, filename, section, vars):
"""Place any commands to setup herder here"""
conf = appconfig('config:' + filename)
load_environment(conf.global_conf, conf.local_conf)
manager = SQLAlchemyManager(None, conf.local_conf,
[setup_model, authkit.users.sqlalchemy_04_driver.setup_model])
manager.create_all()
connection = manager.engine.connect()
session = manager.session_maker(bind=connection)
try:
environ = {}
environ['sqlalchemy.session'] = session
environ['sqlalchemy.model'] = manager.model
users = authkit.users.sqlalchemy_04_driver.UsersFromDatabase(environ)
# create default groups
users.group_create("Users")
# create default roles
for role in CONTEXT_ROLES:
users.role_create(role)
# create the default administrative user
users.user_create("admin", password="******")
for role in CONTEXT_ROLES:
users.user_add_role('admin', role)
# commit the user setup work
session.flush()
session.commit()
finally:
session.close()
connection.close()
def setup_app(command, conf, vars):
"""Place any commands to setup ogameinfo here"""
load_environment(conf.global_conf, conf.local_conf)
# Load the models
meta.metadata.bind = meta.engine
# Create the tables if they aren't there already
log.info("Creating database tables")
meta.metadata.create_all(checkfirst=True)
log.info("Finished setting up")
manager = SQLAlchemyManager(None, conf.local_conf,
[setup_model, authkit.users.sqlalchemy_04_driver.setup_model])
manager.create_all()
connection = manager.engine.connect()
session = manager.session_maker(bind=connection)
try:
environ = {}
environ['sqlalchemy.session'] = session
environ['sqlalchemy.model'] = manager.model
users = authkit.users.sqlalchemy_04_driver.UsersFromDatabase(environ)
session.flush()
session.commit()
finally:
session.close()
connection.close()
def test_users_api_database():
try:
from authkit.users.sqlalchemy_04_driver import UsersFromDatabase, setup_model
except ImportError:
raise Exception("Could not run the SQLAlchemy tests, not installed")
try:
from sqlalchemymanager import SQLAlchemyManager
except ImportError:
raise Exception("Could not run the SQLAlchemy tests, SQLAlchemyManager is not installed")
if os.path.exists("mydb.db"):
os.remove("mydb.db")
app = SQLAlchemyManager(None, {"sqlalchemy.url": "sqlite:///mydb.db"}, [setup_model])
app.create_all()
connection = app.engine.connect()
session = app.session_maker(bind=connection)
try:
environ = {}
environ["sqlalchemy.session"] = session
environ["sqlalchemy.model"] = app.model
d = UsersFromDatabase(environ)
d.role_create("wiki")
d.role_create("adMin")
d.role_create("editor")
d.group_create("pyLOns")
d.group_create("dJAngo")
d.user_create("jaMEs", "passWOrd1", "pyLoNs")
d.user_create("ben", "password2")
d.user_create("Simon", "password3")
d.user_create("ian", "paSsword4")
assertEqual(d.list_roles(), ["admin", "editor", "wiki"])
assertEqual(d.list_groups(), ["django", "pylons"])
assertEqual(d.list_users(), ["ben", "ian", "james", "simon"])
assertEqual(d.user_has_password("james", "passWOrd1"), True)
assertEqual(d.user_has_password("james", "password1"), False)
d.role_create("test_role")
d.group_create("test_group")
d.user_create("test_user", "password")
assertEqual(d.list_roles(), ["admin", "editor", "test_role", "wiki"])
assertEqual(d.list_groups(), ["django", "pylons", "test_group"])
assertEqual(d.list_users(), ["ben", "ian", "james", "simon", "test_user"])
d.role_delete("test_role")
d.group_delete("test_group")
d.user_delete("test_user")
assertEqual(d.list_roles(), ["admin", "editor", "wiki"])
assertEqual(d.list_groups(), ["django", "pylons"])
assertEqual(d.list_users(), ["ben", "ian", "james", "simon"])
assertEqual(d.user_has_role("james", "admin"), False)
d.user_add_role("james", "admin")
assertEqual(d.user_has_role("james", "admin"), True)
d.user_remove_role("james", "admin")
assertEqual(d.user_has_role("james", "admin"), False)
d.user_add_role("james", "wiki")
d.user_add_role("simon", "wiki")
d.user_add_role("james", "admin")
# d.user_add_role("james", "editor")
d.user_add_role("ben", "editor")
assertEqual(d.user_has_group("james", "pylons"), True)
assertEqual(d.user_has_group("simon", None), True)
assertEqual(d.user_has_group("simon", "django"), False)
d.user_set_group("simon", "dJangO")
assertEqual(d.user_has_group("simon", None), False)
d.user_set_group("bEn", "PyLONS")
assertEqual(d.user_has_group("simon", "django"), True)
assertEqual(d.user_has_group("bEn", "pYlons"), True)
d.user_remove_group("bEn")
assertEqual(d.user_has_group("bEn", "pYlons"), False)
d.user_set_group("bEn", "PyLONS")
assertEqual(d.user_has_group("bEn", "pYlons"), True)
assertEqual(d.list_users(), ["ben", "ian", "james", "simon"])
d.user_set_username("james", "jim")
assertEqual(d.list_users(), ["ben", "ian", "jim", "simon"])
d.user_set_username("jim", "james")
from authkit.users import (
UsersFromFile,
UsersFromString,
AuthKitNoSuchUserError,
AuthKitNoSuchGroupError,
AuthKitNoSuchRoleError,
)
string_data = """jaMEs:passWOrd1:pyLOns wiki adMin
ben:password2:pylons admin editor
simon:password3:dJAngo
ian:paSsword4 wiki
"""
filename = "test/user_file_data.txt"
s = UsersFromString(string_data)
f = UsersFromFile(filename)
# Test Parsing
assertAllEqual(
s.passwords,
f.passwords,
{"james": "passWOrd1", "ben": "password2", "simon": "password3", "ian": "paSsword4"},
)
assertAllEqual(
s.roles, f.roles, {"james": ["admin", "wiki"], "ben": ["admin", "editor"], "ian": ["wiki"], "simon": []}
)
assertAllEqual(s.groups, f.groups, {"james": "pylons", "ben": "pylons", "ian": None, "simon": "django"})
assertAllEqual(s.usernames, f.usernames, ["ben", "ian", "james", "simon"])
# Test list functions
assertAllEqual(s.list_users(), f.list_users(), d.list_users(), ["ben", "ian", "james", "simon"])
assertAllEqual(s.list_roles(), f.list_roles(), d.list_roles(), ["admin", "editor", "wiki"])
assertAllEqual(s.list_groups(), f.list_groups(), d.list_groups(), ["django", "pylons"])
# Test user has functions
assertAllEqual(
s.user_has_role("jAMes", "WiKi"), f.user_has_role("jAMes", "WiKi"), d.user_has_role("jAMes", "WiKi"), True
)
assertAllEqual(
s.user_has_role("jAMes", "editOr"),
f.user_has_role("jAMes", "editOr"),
d.user_has_role("jAMes", "editOr"),
False,
)
assertAllEqual(
s.user_has_group("jAMeS", "PyLons"),
f.user_has_group("jAMes", "pylOns"),
d.user_has_group("jAMes", "pylOns"),
True,
)
assertAllEqual(
s.user_has_group("jameS", "djaNgo"),
f.user_has_group("JAMes", "djAngo"),
d.user_has_group("JAMes", "djAngo"),
False,
)
assertAllEqual(
s.user_has_password("jAMeS", "passWOrd1"),
f.user_has_password("jAMes", "passWOrd1"),
d.user_has_password("jAMes", "passWOrd1"),
True,
)
assertAllEqual(
s.user_has_password("jameS", "PASSWORD1"),
f.user_has_password("JAMes", "PASSWORD1"),
d.user_has_password("JAMes", "PASSWORD1"),
False,
)
# Existence Methods
assertAllEqual(s.user_exists("jAMeS"), f.user_exists("jAMes"), d.user_exists("jAMes"), True)
assertAllEqual(s.user_exists("nobody"), f.user_exists("nobody"), d.user_exists("nobody"), False)
# Existence Methods
assertAllEqual(s.role_exists("wiKi"), f.role_exists("Wiki"), d.role_exists("Wiki"), True)
assertAllEqual(s.role_exists("norole"), f.role_exists("norole"), d.role_exists("norole"), False)
assertAllEqual(s.group_exists("pyLons"), f.group_exists("PYlons"), d.group_exists("PYlons"), True)
assertAllEqual(s.group_exists("nogroup"), f.group_exists("nogroup"), d.group_exists("nogroup"), False)
# User Methods
assertAllEqual(
s.user("James"),
f.user("James"),
d.user("James"),
{"username": "******", "group": "pylons", "password": "******", "roles": ["admin", "wiki"]},
)
# Test all user methods raise:
for plugin in [s, f, d]:
for func in ["user", "user_roles", "user_group", "user_password"]:
try:
getattr(plugin, func)("nouser")
except AuthKitNoSuchUserError, e:
pass
else:
raise AssertionError("Failed to throw a no user error")
for plugin in [s, f, d]:
for func in ["user_has_password", "user_has_role", "user_has_group"]:
try:
getattr(plugin, func)("nouser", "somevar")
except AuthKitNoSuchUserError, e:
pass
else:
raise AssertionError("Failed to throw a no user error")
from sqlalchemymanager import SQLAlchemyManager
import authkit.users.sqlalchemy_04_driver
import os
# os.remove('test.db')
app = SampleApp()
app = middleware(
app,
setup_method='form,cookie',
cookie_secret='secret encryption string',
form_authenticate_user_type=
"authkit.users.sqlalchemy_04_driver:UsersFromDatabase",
cookie_signoutpath='/signout',
setup_intercept="401, 403",
)
app = SQLAlchemyManager(app, {'sqlalchemy.url': 'sqlite:///test.db'},
[authkit.users.sqlalchemy_04_driver.setup_model])
app.create_all()
connection = app.engine.connect()
session = app.session_maker(bind=connection)
try:
environ = {}
environ['sqlalchemy.session'] = session
environ['sqlalchemy.model'] = app.model
users = authkit.users.sqlalchemy_04_driver.UsersFromDatabase(environ)
users.group_create("pylons")
users.role_create("admin")
users.user_create("james", password="******", group="pylons")
users.user_create("ben", password="******")
users.user_add_role("ben", role="admin")
session.flush()
session.commit()
def load_environment(global_conf, app_conf):
"""Configure the Pylons environment via the ``pylons.config``
object
"""
# Pylons paths
root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
paths = dict(root=root,
controllers=os.path.join(root, 'controllers'),
static_files=os.path.join(root, 'public'),
templates=[os.path.join(root, 'templates')])
# Initialize config with the basic options
config.init_app(global_conf, app_conf, package='herder',
template_engine='mako', paths=paths)
config['routes.map'] = make_map()
config['pylons.g'] = app_globals.Globals()
config['pylons.h'] = herder.lib.helpers
# Customize templating options via this variable
tmpl_options = config['buffet.template_options']
# CONFIGURATION OPTIONS HERE (note: all config options will override
# any Pylons config options)
config['pylons.g'].sa_engine = engine = \
sa.engine_from_config(config, "sqlalchemy.")
model.init_model(engine)
# Sync up roles
manager = SQLAlchemyManager(None, config,
[model.setup_model, authkit.users.sqlalchemy_04_driver.setup_model])
manager.create_all()
connection = manager.engine.connect()
session = manager.session_maker(bind=connection)
try:
environ = {}
environ['sqlalchemy.session'] = session
environ['sqlalchemy.model'] = manager.model
users = authkit.users.sqlalchemy_04_driver.UsersFromDatabase(environ)
# sync up the roles for each domain and language
for domain in model.Domain.all():
for cr in CONTEXT_ROLES:
if not users.role_exists('domain-%s-%s' % (domain.name, cr)):
users.role_create('domain-%s-%s' % (domain.name, cr))
for lang in domain.languages:
for cr in CONTEXT_ROLES:
if not users.role_exists('lang-%s-%s' % (lang.name, cr)):
users.role_create('lang-%s-%s' % (lang.name, cr))
# commit the user setup work
session.flush()
session.commit()
finally:
session.close()
connection.close()
def test_users_api_database():
try:
from authkit.users.sqlalchemy_04_driver import UsersFromDatabase, setup_model
except ImportError:
raise Exception("Could not run the SQLAlchemy tests, not installed")
try:
from sqlalchemymanager import SQLAlchemyManager
except ImportError:
raise Exception("Could not run the SQLAlchemy tests, SQLAlchemyManager is not installed")
if os.path.exists("mydb.db"):
os.remove("mydb.db")
app = SQLAlchemyManager(
None,
{'sqlalchemy.url':'sqlite:///mydb.db'},
[setup_model]
)
app.create_all()
connection = app.engine.connect()
session = app.session_maker(bind=connection)
try:
environ = {}
environ['sqlalchemy.session'] = session
environ['sqlalchemy.model'] = app.model
d = UsersFromDatabase(environ)
d.role_create("wiki")
d.role_create("adMin")
d.role_create("editor")
d.group_create("pyLOns")
d.group_create("dJAngo")
d.user_create("jaMEs", "passWOrd1", "pyLoNs")
d.user_create("ben", "password2")
d.user_create("Simon", "password3")
d.user_create("ian", "paSsword4")
assertEqual(d.list_roles(),["admin", "editor", "wiki"])
assertEqual(d.list_groups(),["django", "pylons"])
assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon'])
assertEqual(d.user_has_password("james", "passWOrd1"), True)
assertEqual(d.user_has_password("james", "password1"), False)
d.role_create("test_role")
d.group_create("test_group")
d.user_create("test_user", "password")
assertEqual(d.list_roles(),["admin", "editor", "test_role", "wiki"])
assertEqual(d.list_groups(),["django", "pylons", "test_group"])
assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon', "test_user"])
d.role_delete("test_role")
d.group_delete("test_group")
d.user_delete("test_user")
assertEqual(d.list_roles(),["admin", "editor", "wiki"])
assertEqual(d.list_groups(),["django", "pylons"])
assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon'])
assertEqual(d.user_has_role("james", "admin"), False)
d.user_add_role("james", "admin")
assertEqual(d.user_has_role("james", "admin"), True)
d.user_remove_role("james", "admin")
assertEqual(d.user_has_role("james", "admin"), False)
d.user_add_role("james", "wiki")
d.user_add_role("simon", "wiki")
d.user_add_role("james", "admin")
#d.user_add_role("james", "editor")
d.user_add_role("ben", "editor")
assertEqual(d.user_has_group("james", "pylons"), True)
assertEqual(d.user_has_group("simon", None), True)
assertEqual(d.user_has_group("simon", "django"), False)
d.user_set_group("simon", "dJangO")
assertEqual(d.user_has_group("simon", None), False)
d.user_set_group("bEn", "PyLONS")
assertEqual(d.user_has_group("simon", "django"), True)
assertEqual(d.user_has_group("bEn", "pYlons"), True)
d.user_remove_group("bEn")
assertEqual(d.user_has_group("bEn", "pYlons"), False)
d.user_set_group("bEn", "PyLONS")
assertEqual(d.user_has_group("bEn", "pYlons"), True)
assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon'])
d.user_set_username("james", "jim")
assertEqual(d.list_users(),['ben', 'ian', 'jim', 'simon'])
d.user_set_username("jim", "james")
from authkit.users import UsersFromFile, UsersFromString, AuthKitNoSuchUserError, AuthKitNoSuchGroupError,AuthKitNoSuchRoleError
string_data = """jaMEs:passWOrd1:pyLOns wiki adMin
ben:password2:pylons admin editor
simon:password3:dJAngo
ian:paSsword4 wiki
"""
filename = 'test/user_file_data.txt'
s = UsersFromString(string_data)
f = UsersFromFile(filename)
# Test Parsing
assertAllEqual(
s.passwords,
f.passwords,
{
'james':'passWOrd1',
'ben':'password2',
'simon':'password3',
'ian':'paSsword4',
},
)
assertAllEqual(
s.roles,
f.roles,
{
'james':['admin', 'wiki'],
'ben':['admin','editor'],
'ian':['wiki'],
'simon':[],
},
)
assertAllEqual(
s.groups,
f.groups,
{
'james':'pylons',
'ben':'pylons',
'ian': None,
'simon':'django',
},
)
assertAllEqual(
s.usernames,
f.usernames,
['ben', 'ian', 'james', 'simon'],
)
# Test list functions
assertAllEqual(
s.list_users(),
f.list_users(),
d.list_users(),
['ben', 'ian', 'james', 'simon'],
)
assertAllEqual(
s.list_roles(),
f.list_roles(),
d.list_roles(),
['admin', 'editor', 'wiki'],
)
assertAllEqual(
s.list_groups(),
f.list_groups(),
d.list_groups(),
['django','pylons'],
)
# Test user has functions
assertAllEqual(
s.user_has_role('jAMes','WiKi'),
f.user_has_role('jAMes','WiKi'),
d.user_has_role('jAMes','WiKi'),
True
)
assertAllEqual(
s.user_has_role('jAMes','editOr'),
f.user_has_role('jAMes','editOr'),
d.user_has_role('jAMes','editOr'),
False
)
assertAllEqual(
s.user_has_group('jAMeS','PyLons'),
f.user_has_group('jAMes','pylOns'),
d.user_has_group('jAMes','pylOns'),
True
)
assertAllEqual(
s.user_has_group('jameS','djaNgo'),
f.user_has_group('JAMes','djAngo'),
d.user_has_group('JAMes','djAngo'),
False
)
assertAllEqual(
s.user_has_password('jAMeS','passWOrd1'),
f.user_has_password('jAMes','passWOrd1'),
d.user_has_password('jAMes','passWOrd1'),
True
)
assertAllEqual(
s.user_has_password('jameS','PASSWORD1'),
f.user_has_password('JAMes','PASSWORD1'),
d.user_has_password('JAMes','PASSWORD1'),
False
)
# Existence Methods
assertAllEqual(
s.user_exists('jAMeS'),
f.user_exists('jAMes'),
d.user_exists('jAMes'),
True
)
assertAllEqual(
s.user_exists('nobody'),
f.user_exists('nobody'),
d.user_exists('nobody'),
False
)
# Existence Methods
assertAllEqual(
s.role_exists('wiKi'),
f.role_exists('Wiki'),
d.role_exists('Wiki'),
True
)
assertAllEqual(
s.role_exists('norole'),
f.role_exists('norole'),
d.role_exists('norole'),
False
)
assertAllEqual(
s.group_exists('pyLons'),
f.group_exists('PYlons'),
d.group_exists('PYlons'),
True
)
assertAllEqual(
s.group_exists('nogroup'),
f.group_exists('nogroup'),
d.group_exists('nogroup'),
False
)
# User Methods
assertAllEqual(
s.user('James'),
f.user('James'),
d.user('James'),
{
'username': '******',
'group': 'pylons',
'password': '******',
'roles': ['admin','wiki'],
}
)
# Test all user methods raise:
for plugin in [s,f,d]:
for func in [
'user',
'user_roles',
'user_group',
'user_password',
]:
try:
getattr(plugin, func)('nouser')
except AuthKitNoSuchUserError, e:
pass
else:
raise AssertionError("Failed to throw a no user error")
for plugin in [s,f,d]:
for func in [
'user_has_password',
'user_has_role',
'user_has_group',
]:
try:
getattr(plugin, func)('nouser','somevar')
except AuthKitNoSuchUserError, e:
pass
else:
raise AssertionError("Failed to throw a no user error")
def test_users_api_database():
try:
from authkit.users.sqlalchemy_04_driver import UsersFromDatabase, setup_model
except ImportError:
raise Exception("Could not run the SQLAlchemy tests, not installed")
try:
from sqlalchemymanager import SQLAlchemyManager
except ImportError:
raise Exception("Could not run the SQLAlchemy tests, SQLAlchemyManager is not installed")
if os.path.exists("mydb.db"):
os.remove("mydb.db")
app = SQLAlchemyManager(
None,
{'sqlalchemy.url':'sqlite:///mydb.db'},
[setup_model]
)
app.create_all()
connection = app.engine.connect()
session = app.session_maker(bind=connection)
try:
environ = {}
environ['sqlalchemy.session'] = session
environ['sqlalchemy.model'] = app.model
d = UsersFromDatabase(environ)
d.role_create("wiki")
d.role_create("adMin")
d.role_create("editor")
d.group_create("pyLOns")
d.group_create("dJAngo")
d.user_create("jaMEs", "passWOrd1", "pyLoNs")
d.user_create("ben", "password2")
d.user_create("Simon", "password3")
d.user_create("ian", "paSsword4")
assertEqual(d.list_roles(),["admin", "editor", "wiki"])
assertEqual(d.list_groups(),["django", "pylons"])
assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon'])
assertEqual(d.user_has_password("james", "passWOrd1"), True)
assertEqual(d.user_has_password("james", "password1"), False)
d.role_create("test_role")
d.group_create("test_group")
d.user_create("test_user", "password")
assertEqual(d.list_roles(),["admin", "editor", "test_role", "wiki"])
assertEqual(d.list_groups(),["django", "pylons", "test_group"])
assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon', "test_user"])
d.role_delete("test_role")
d.group_delete("test_group")
d.user_delete("test_user")
assertEqual(d.list_roles(),["admin", "editor", "wiki"])
assertEqual(d.list_groups(),["django", "pylons"])
assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon'])
assertEqual(d.user_has_role("james", "admin"), False)
d.user_add_role("james", "admin")
assertEqual(d.user_has_role("james", "admin"), True)
d.user_remove_role("james", "admin")
assertEqual(d.user_has_role("james", "admin"), False)
d.user_add_role("james", "wiki")
d.user_add_role("simon", "wiki")
d.user_add_role("james", "admin")
#d.user_add_role("james", "editor")
d.user_add_role("ben", "editor")
assertEqual(d.user_has_group("james", "pylons"), True)
assertEqual(d.user_has_group("simon", None), True)
assertEqual(d.user_has_group("simon", "django"), False)
d.user_set_group("simon", "dJangO")
assertEqual(d.user_has_group("simon", None), False)
d.user_set_group("bEn", "PyLONS")
assertEqual(d.user_has_group("simon", "django"), True)
assertEqual(d.user_has_group("bEn", "pYlons"), True)
d.user_remove_group("bEn")
assertEqual(d.user_has_group("bEn", "pYlons"), False)
d.user_set_group("bEn", "PyLONS")
assertEqual(d.user_has_group("bEn", "pYlons"), True)
assertEqual(d.list_users(),['ben', 'ian', 'james', 'simon'])
d.user_set_username("james", "jim")
assertEqual(d.list_users(),['ben', 'ian', 'jim', 'simon'])
d.user_set_username("jim", "james")
from authkit.users import UsersFromFile, UsersFromString, AuthKitNoSuchUserError, AuthKitNoSuchGroupError,AuthKitNoSuchRoleError
string_data = """jaMEs:passWOrd1:pyLOns wiki adMin
ben:password2:pylons admin editor
simon:password3:dJAngo
ian:paSsword4 wiki
"""
filename = 'test/user_file_data.txt'
s = UsersFromString(string_data)
f = UsersFromFile(filename)
# Test Parsing
assertAllEqual(
s.passwords,
f.passwords,
{
'james':'passWOrd1',
'ben':'password2',
'simon':'password3',
'ian':'paSsword4',
},
)
assertAllEqual(
s.roles,
f.roles,
{
'james':['admin', 'wiki'],
'ben':['admin','editor'],
'ian':['wiki'],
'simon':[],
},
)
assertAllEqual(
s.groups,
f.groups,
{
'james':'pylons',
'ben':'pylons',
'ian': None,
'simon':'django',
},
)
assertAllEqual(
s.usernames,
f.usernames,
['ben', 'ian', 'james', 'simon'],
)
# Test list functions
assertAllEqual(
s.list_users(),
f.list_users(),
d.list_users(),
['ben', 'ian', 'james', 'simon'],
)
assertAllEqual(
s.list_roles(),
f.list_roles(),
d.list_roles(),
['admin', 'editor', 'wiki'],
)
assertAllEqual(
s.list_groups(),
f.list_groups(),
d.list_groups(),
['django','pylons'],
)
# Test user has functions
assertAllEqual(
s.user_has_role('jAMes','WiKi'),
f.user_has_role('jAMes','WiKi'),
d.user_has_role('jAMes','WiKi'),
True
)
assertAllEqual(
s.user_has_role('jAMes','editOr'),
f.user_has_role('jAMes','editOr'),
d.user_has_role('jAMes','editOr'),
False
)
assertAllEqual(
s.user_has_group('jAMeS','PyLons'),
f.user_has_group('jAMes','pylOns'),
d.user_has_group('jAMes','pylOns'),
True
)
assertAllEqual(
s.user_has_group('jameS','djaNgo'),
f.user_has_group('JAMes','djAngo'),
d.user_has_group('JAMes','djAngo'),
False
)
assertAllEqual(
s.user_has_password('jAMeS','passWOrd1'),
f.user_has_password('jAMes','passWOrd1'),
d.user_has_password('jAMes','passWOrd1'),
True
)
assertAllEqual(
s.user_has_password('jameS','PASSWORD1'),
f.user_has_password('JAMes','PASSWORD1'),
d.user_has_password('JAMes','PASSWORD1'),
False
)
# Existence Methods
assertAllEqual(
s.user_exists('jAMeS'),
f.user_exists('jAMes'),
d.user_exists('jAMes'),
True
)
assertAllEqual(
s.user_exists('nobody'),
f.user_exists('nobody'),
d.user_exists('nobody'),
False
)
# Existence Methods
assertAllEqual(
s.role_exists('wiKi'),
f.role_exists('Wiki'),
d.role_exists('Wiki'),
True
)
assertAllEqual(
s.role_exists('norole'),
f.role_exists('norole'),
d.role_exists('norole'),
False
)
assertAllEqual(
s.group_exists('pyLons'),
f.group_exists('PYlons'),
d.group_exists('PYlons'),
True
)
assertAllEqual(
s.group_exists('nogroup'),
f.group_exists('nogroup'),
d.group_exists('nogroup'),
False
)
# User Methods
assertAllEqual(
s.user('James'),
f.user('James'),
d.user('James'),
{
'username': '******',
'group': 'pylons',
'password': '******',
'roles': ['admin','wiki'],
}
)
# Test all user methods raise:
for plugin in [s,f,d]:
for func in [
'user',
'user_roles',
'user_group',
'user_password',
]:
try:
getattr(plugin, func)('nouser')
except AuthKitNoSuchUserError, e:
pass
else:
raise AssertionError("Failed to throw a no user error")
for plugin in [s,f,d]:
for func in [
'user_has_password',
'user_has_role',
'user_has_group',
]:
try:
getattr(plugin, func)('nouser','somevar')
except AuthKitNoSuchUserError, e:
pass
else:
raise AssertionError("Failed to throw a no user error")
