class SimpleEntries:
def __init__(self):
self.testMain = testMain()
self.userDB = UserDB()
self.entryDB = EntryDB()
self.roleDB = RoleDB()
u = self.userDB.add("criswell", "password", "Sam Hart")
u1 = self.userDB.add("charles", "password", "Charles Xavier")
u2 = self.userDB.add("leif", "password", "Lief Ericsson")
u3 = self.userDB.add("barf", "password", "Barfy Barferson")
u4 = self.userDB.add("squiddy", "password", "Squidward Tentacles")
editors = ['charles', 'leif', 'barf', 'squiddy']
all_groups = ['junkbar', 'dollarbillyall', 'coldnwet']
for g in all_groups:
self.userDB.add_group(g)
role_names = ['tomato', 'spaghetti', 'nuts']
role_desc = ['Tomato Paste', 'Swirly Cheesy', 'Hardcore Nuts']
for x in range(len(role_names)):
self.roleDB.add_role(
role_names[x],
role_desc[x])
parents = []
for e in entries:
parent = None
if randint(0,5) > 3 and len(parents) > 1:
parent = parents[randint(0,len(parents)-1)]
print("A parent is {0}".format(parent))
try:
entry = self.entryDB.add(e[0], e[1], u, None, e[2], e[3], e[5], parent)
if e[4]:
self.entryDB.add_tag(e[4], entry)
if randint(0,5) > 2:
parents.append(entry)
if randint(0,5) > 2:
for ed in sample(editors, randint(1,len(editors)-1)):
self.entryDB.update_editor(ed, entry)
except:
print("Dropping an entry due to some entryDB problem (likely duplicate URL")
print("because of random URL generation- Should be safe to ignore)\n")
pass # stupid, but for our tests we don't care we just may get duplicate URLs
def __del__(self):
del(self.testMain)
def run(self, debug):
print("mainApp.jinja_env")
print("-----------------")
print("\nmainApp.jinja_loader")
print("___________________")
print("\n%s" % mainApp.jinja_loader.searchpath)
mainApp.run(host="0.0.0.0", debug=debug)
def setup_DB():
"""
Called when the DB is to be initialized. Should only be called once.
"""
event_log = EventLog()
sc = _SiteConfig()
userDB = UserDB()
roleDB = RoleDB()
mainDB.create_all()
event_log.add('db_setup', -1, True)
default_group = userDB.add_group(mainApp.config['DEFAULT_GROUP'],
mainApp.config['DEFAULT_GROUP_DESC'])
default_acts = get_activity_dict(False)
default_acts.update(mainApp.config['DEFAULT_ROLE_ACTIVITIES'])
dummy = roleDB.add_role(
mainApp.config['DEFAULT_ROLE_NAME'],
mainApp.config['DEFAULT_ROLE_DESC'],
default_acts)
user = userDB.add(mainApp.config['ADMIN_USER'],
mainApp.config["ADMIN_PASSWD"], mainApp.config['ADMIN_FULLNAME'])
admin_group = userDB.add_group(mainApp.config['ADMIN_GROUP'],
mainApp.config['ADMIN_GROUP_DESC'], user.id)
if not userDB.update_primary(user, admin_group):
raise SetupError(
'Could not assign the admin user "{0}" primary group to the ' \
'admin group "{1}"!'.format(user, admin_group))
# By default, the admin is part of the top level group as well as default
dummy = userDB.add_group(mainApp.config['TOP_LEVEL_GROUP'],
mainApp.config['TOP_LEVEL_GROUP_DESC'], user.id)
userDB.add_to_group(user, default_group)
admin_role = get_activity_dict(True)
role = roleDB.add_role(
mainApp.config['ADMIN_ROLE_NAME'],
mainApp.config['ADMIN_ROLE_DESC'],
admin_role)
roleDB.assign_role(user, mainApp.config['ADMIN_GROUP'], role)
roleDB.assign_role(user, mainApp.config['TOP_LEVEL_GROUP'], role)
roleDB.assign_role(user, mainApp.config['DEFAULT_GROUP'], role)
sc.add(mainApp.noink_version, mainApp.config['SITE_NAME'],
mainApp.config['SITE_ADMIN_EMAIL'])
event_log.add('db_finish', -1, True)
def test_AddToGroup(self):
user_db = UserDB()
u = user_db.add("jontest", "pass", "Jon Q. Testuser")
g = user_db.add_group('test_group')
gid = g.id
user_db.add_to_group(u, g)
groups = set(user_db.get_users_groups(u))
self.assertTrue(g in groups)
def test_AssignRole(self):
user_db = UserDB()
role_db = RoleDB()
u = user_db.add("jontest", "pass", "Jon Q. Testuser")
g = user_db.add_group('test_group')
user_db.add_to_group(u, g)
r = role_db.add_role('test_role', 'test role', get_activity_dict(True))
role_db.assign_role(u, g, r)
all_roles = set(rm.role for rm in role_db.get_roles(u))
self.assertTrue(r in all_roles)
def test_RmFromGroup(self):
userDB = UserDB()
u = userDB.add("jontest", "pass", "Jon Q. Testuser")
g_foo = userDB.add_group('foo')
g_bar = userDB.add_group('bar')
self.assertTrue(userDB.update_primary(u, g_foo))
userDB.add_to_group(u, g_bar)
self.assertTrue(userDB.in_group(u, g_bar))
self.assertTrue(userDB.remove_from_group(u, g_bar))
self.assertFalse(userDB.in_group(u, g_bar))
def test_AssignRole(self):
user_db = UserDB()
role_db = RoleDB()
u = user_db.add("jontest", "pass", "Jon Q. Testuser")
g = user_db.add_group('test_group')
user_db.add_to_group(u, g)
r = role_db.add_role('test_role', 'test role', get_activity_dict(True))
role_db.assign_role(u, g, r)
all_roles_1st = set(rm.role for rm in role_db.get_roles(u))
was_in_before = r in all_roles_1st
role_db.revoke_role(u, g, r)
all_roles_2nd = set(rm.role for rm in role_db.get_roles(u))
not_in_after = r not in all_roles_2nd
self.assertTrue(was_in_before and not_in_after)
def admin_new_group():
"""
Renders the new group page
"""
user_db = UserDB()
role_db = RoleDB()
if current_user.is_authenticated() and current_user.is_active():
all_activities = set()
for m in role_db.get_roles(current_user):
acts = role_db.get_activities(m.role_id)
for act in acts:
if acts[act]:
all_activities.add(act)
if 'new_group' in all_activities:
group = user_db.create_temp_empty_group()
if 'cancel' in request.form:
return redirect(url_for('admin_group.admin_group_page'))
elif 'submit' in request.form:
gname = request.form.get('group_name', None)
group.name = gname
group.description = request.form.get('description', None)
if gname is not None and gname != '':
g = user_db.get_group(gname)
if g is None:
try:
group = user_db.add_group(group.name,
group.description)
flash(_('Group "{0}" added.'.format(gname)))
return redirect(url_for(
'admin_group.admin_group_page'))
except DuplicateGroup:
flash(_(
'Group name "{0}" is already in use!'.format(
gname)),
'error')
else:
flash(_("Group name cannot be empty!"), 'error')
return render_template('admin_group.html', group=group,
state=get_state(), title=_('Edit Group'),
cancel_button=_('Cancel'), submit_button=_('Submit'),
can_edit_groups=True)
else:
return _not_auth()
else:
return _not_auth()
def test_AddGroup(self):
user_db = UserDB()
g = user_db.add_group('test_group')
self.assertTrue(g.id > 0)
def test_UpdatePrimary(self):
user_db = UserDB()
u = user_db.add("jontest", "pass", "Jon Q. Testuser")
g = user_db.add_group("test_group")
self.assertTrue(user_db.update_primary(u, g))
