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 test_DelUser(self): userDB = UserDB() uid = userDB.add("jontest", "pass", "Jon Q. Testuser").id userDB.delete(uid) testUser = userDB.find_user_by_id(uid) self.assertTrue(testUser == None)
def test_UpdatePassword(self): user_db = UserDB() u = user_db.add("jontest", "pass", "Jon Q. Testuser") passwd = 'A Test Password' self.assertFalse(mainCrypt.check_password_hash(u.passhash, passwd)) user_db.update_password(u, passwd) self.assertTrue(mainCrypt.check_password_hash(u.passhash, passwd))
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_AddEntry(self): userDB = UserDB() entryDB = EntryDB() u = userDB.add("jontest", "pass", "Jon Q. Testuser") title = 'Little Buttercup' entry = 'There once was a man from Nantucket,' + \ 'who kept his wife in a Bucket.' + \ "Wait... how'd she fit in that bucket anyway?" e = entryDB.add(copy.deepcopy(title), entry, u) self.assertTrue(e.title == title)
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 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 new_user(): """ Dialog for new user. """ user_db = UserDB() role_db = RoleDB() if current_user.is_authenticated() and current_user.is_active(): is_admin = user_db.in_group(current_user, mainApp.config["ADMIN_GROUP"]) 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_user" in all_activities: user = user_db.create_temp_empty_user() groups = user_db.get_all_groups() if "cancel" in request.form: return redirect(request.args.get("next") or url_for("admin.admin_page")) elif "update" in request.form: password = _check_password(request.form.get("password", None), request.form.get("pcheck", None)) user.name = _check_username(request.form.get("name", None)) user.fullname = request.form.get("fullname", None) user.bio = request.form.get("bio", None) g = user_db.get_group(request.form.get("primary_group", None)) user.primary_group_id = g.id user.active = request.form.get("active", None) == "on" # Validation if user.name is not None: if password is not None: if g is not None: u = user_db.add(user.name, password, user.fullname, user.bio, g, user.active) flash(_('User "{0}" added.'.format(u.name))) return redirect(url_for("admin_user.admin_user_page", uid=u.id)) else: flash(_("Invalid group")) else: flash(_("Passwords do not match!")) else: flash(_("Username invalid")) return render_template( "admin_new_user.html", state=get_state(), user=user, groups=groups, title=_("Add new user"), can_edit_users=True, is_admin=is_admin, submit_button=_("Add"), cancel_button=_("Cancel"), ) else: return _not_auth() return _not_auth()
def test_AddUser(self): userDB = UserDB() u = userDB.add("jontest", "pass", "Jon Q. Testuser") uid = u.id self.assertTrue(uid > 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))