def setUp(self): check_permissions() self.username = "******" create_user(self.username) self.browser = Browser() self.browser.visit(self.live_server_url)
def fbconnect(): if request.args.get('state') != session['state']: response = make_response(json.dumps('Invalid state token'), 401) response.headers['Content-Type'] = 'application/json' return response access_token = request.data # Exchange client token for long-lived server-side token app_id = json.loads( open('fb_client_secrets.json', 'r').read() )['web']['app_id'] app_secret = json.loads( open('fb_client_secrets.json', 'r').read() )['web']['app_secret'] url = 'https://graph.facebook.com/oauth/' \ 'access_token?grant_type=fb_exchange_token&' \ 'client_id=%s&client_secret=%s&fb_exchange_token=%s' \ % (app_id, app_secret, access_token) h = httplib2.Http() result = h.request(url, 'GET')[1] # Use token to get user info token = json.loads(result)['access_token'] userinfo_url = \ 'https://graph.facebook.com/v2.8/me?access_token=%s' \ '&fields=name,id,email' % token h = httplib2.Http() result = h.request(userinfo_url, 'GET')[1] data = json.loads(result) session['provider'] = 'Facebook' session['username'] = data['name'] # email can be empty # if someone signup with phone number or email is not confirmed # save as [email protected] to hack around session['email'] = data.get('email', data['id'] + '@facebook.com') session['facebook_id'] = data['id'] # The token must be stored in the session in order to properly logout session['access_token'] = token # Get user picture userpic_url = \ 'https://graph.facebook.com/v2.8/me/picture?access_token=%s' \ '&redirect=0&height=200&width=200' % token h = httplib2.Http() result = h.request(userpic_url, 'GET')[1] data = json.loads(result) session['picture'] = data['data']['url'] # store user into db if utils.get_user_id_by_email(session['email'], db_session) is None: utils.create_user(session, db_session) flash('You are now logged in as %s' % session['username']) return redirect(url_for('showCompanies'))
def setUp(self): cache.clear() self.user = utils.create_user() self.user2 = utils.create_user() self.category = utils.create_category() self.topic = utils.create_topic(self.category, user=self.user2) self.topic2 = utils.create_topic(self.category)
def test_one_user_only_verify_2_times(self): identifier = '13800000000' password = '******' create_user(identifier=identifier, password=password, nickname=identifier) self.client.login(identifier=identifier, password=password) response = self.client.post("/accounts/id_verify/", { 'name': 'testName', 'id_number': '12386718523671243574' }) self.assertEqual(response.status_code, 302) response = self.client.post("/accounts/id_verify/", { 'name': 'testName', 'id_number': '12386718523671243574' }) self.assertEqual(response.status_code, 302) response = self.client.post("/accounts/id_verify/", { 'name': 'testName', 'id_number': '12386718523671243574' }) self.assertEqual(response.status_code, 200)
def clear(user_id): utils.create_user(user_id) for name in os.listdir(f"data/{user_id}/workouts/"): path = f"data/{user_id}/workouts/{name}" with open(path, "w") as f: f.write("{}") return f"All workouts cleared successfully!"
def remove(user_id, name): utils.create_user(user_id) path = f"data/{user_id}/workouts/{name}.json" if not os.path.isfile(path): raise ValueError("Invalid command: this exercise doesn't exist.") os.remove(path) return f"Workout {name} removed successfully!"
def add_users(count) -> None: """Retrieve 10 users and generate passwords for each user Save the name, email and password in a sqlite database :return: None """ for _ in range(count): create_user('user_info.db') with sqlite3.connect('user_info.db') as connection: cursor = connection.cursor() cursor.execute("SELECT name FROM sqlite_master WHERE type='table'") table_name = cursor.fetchall()[0][0] try: cursor.execute("ALTER TABLE " + table_name + " ADD COLUMN password") except sqlite3.OperationalError: pass finally: for i in range(1, count + 1): cursor.execute( "UPDATE " + table_name + " SET password=? WHERE id=?", (generate_password(random.choice(range(6, 13)), random.choice(range(1, 5))), i))
def new(user_id, name): utils.create_user(user_id) path = f"data/{user_id}/workouts/{name}.json" if os.path.isfile(path): raise ValueError("Invalid command: this exercise already exists.") utils.create_json_dict(path) return f"Workout {name} created successfully!"
def setUp(self): cache.clear() self.user = utils.create_user() self.user2 = utils.create_user() self.category = utils.create_category() self.topic = utils.create_topic(self.category) self.comment = utils.create_comment(topic=self.topic) # comment notification self.topic_notification = TopicNotification.objects.create( user=self.user, topic=self.topic, comment=self.comment, is_active=True, action=COMMENT) self.topic_notification2 = TopicNotification.objects.create( user=self.user2, topic=self.topic, comment=self.comment, is_active=True, action=COMMENT) # subscription to topic self.topic2 = utils.create_topic(self.category) self.topic_subscrption = TopicNotification.objects.create( user=self.user, topic=self.topic2, is_active=True)
def setUp(self): check_permissions() self.username = '******' create_user(self.username) self.browser = Browser() self.browser.visit(self.live_server_url)
def show_shopgroups_list(user_id): utils.create_user(user_id) path = f"data/{user_id}/shopgroups.json" with open(path, "r") as f: groups = json.load(f) lines = ["*Your shopgroups:*"] + [f"\\* {group}" for group in groups] return "\n".join(lines)
def add_user(): form = request.form try: utils.create_user(username=form['username'], password=form['password'], \ role=form['role'], active=True) flash(messages.USER_CREATED, 'success') except Exception, e: flash('{0} {1}'.format(messages.NEW_USER_ERROR, e), 'error')
def show_list(user_id): utils.create_user(user_id) path = f"data/{user_id}/links.json" with open(path, "r") as f: data = json.load(f) lines = ["Your links:" ] + [f"\\* {name}: {url}" for name, url in data.items()] return "\n".join(lines)
def get(user_id, name): utils.create_user(user_id) path = f"data/{user_id}/links.json" with open(path, "r") as f: data = json.load(f) if name not in data: raise ValueError("Invalid command: link name not found") return data[name]
def add_user(): form = request.form try: utils.create_user(username=form['username'], email=form['email'], \ password=form['password'], role=form['role'], enabled=True) flash(messages.USER_CREATED, 'success') except Exception, e: flash('{0} {1}'.format(messages.NEW_USER_ERROR, e), 'error')
def start(message): utils.create_user(message.chat.id) markup = ReplyKeyboardMarkup(resize_keyboard=True) markup.add('My tasks', 'Create task') markup.add('Deleted tasks', 'Completed tasks') bot.reply_to(message, 'Hello {}'.format(message.from_user.first_name), reply_markup=markup)
def remove(user_id, event): utils.create_user(user_id) path = f"data/{user_id}/calendar.json" with open(path, "r") as f: current = json.load(f) current.pop(event, None) with open(path, "w") as f: json.dump(current, f, indent=4) return show_calendar(user_id)
def add(user_id, event, date): utils.create_user(user_id) path = f"data/{user_id}/calendar.json" with open(path, "r") as f: current = json.load(f) current[event] = date with open(path, "w") as f: json.dump(current, f, indent=4) return show_calendar(user_id)
def add(user_id, name, url): utils.create_user(user_id) path = f"data/{user_id}/links.json" with open(path, "r") as f: data = json.load(f) data[name] = url with open(path, "w") as f: json.dump(data, f, indent=4) return "Your link was added successfully!"
def test_add_user(self): try: utils.create_user(self.client, 'test123', 'test123', '*****@*****.**', self.p1.id, self.d1.id) except: self.fail('Unexpected exception raised: ' 'utils.create_user(' 'self.client, \'test123\', \'test123\',' '\'[email protected]\', self.p1.id,' 'self.d1.id)')
def register(): if request.method == 'POST': user_info_dict = dict(request.form) data = {k: v[0] for k, v in user_info_dict.iteritems()} print data create_user('user', data) res = {'msg': 'register successfully'} return render_template('susccess.html', res=res) res = {'msg': ''} return render_template('register.html', res=res)
def test_do_notify(self): # first create 3 user here user1 = utils.create_user('*****@*****.**') user2 = utils.create_user('*****@*****.**') user3 = utils.create_user('*****@*****.**') # clear inbox to delete all activate emails self.clear_inbox() old_datetime = datetime(2000, 1, 1).replace(tzinfo=tz) s1 = user1.setting s1.notify = True s1.timezone = '11.0' s1.preferhour = 1 s1.nexttime = old_datetime s1.save() s2 = user2.setting s2.notify = True s2.timezone = '-9.0' s2.preferhour = 8 s2.nexttime = old_datetime s2.save() s3 = user3.setting s3.notify = True s3.timezone = '8.0' s3.preferhour = 22 s3.nexttime = datetime(2100, 1, 1).replace(tzinfo=tz) # future time s3.save() tasks.do_notify() # check result today = datetime.utcnow().replace(tzinfo=timezone.utc) mails1 = self.recv_mail(user1) self.assertEqual(len(mails1), 1) subject = mails1[0].get('Subject') t1 = today + timedelta(hours=11) self.assertIn("%s %d" % (t1.strftime('%b'), t1.day), subject) # check next timestamp nexttime = Setting.objects.get(user=user1).nexttime self.assertTrue(old_datetime.toordinal() < nexttime.toordinal()) mails2 = self.recv_mail(user2) self.assertEqual(len(mails2), 1) subject = mails2[0].get('Subject') t2 = today + timedelta(hours=-9) self.assertIn("%s %d" % (t2.strftime('%b'), t2.day), subject) # user3 should not recv notify mail mails3 = self.recv_mail(user3) self.assertEqual(len(mails3), 0)
def setUp(self): cache.clear() self.user = utils.create_user() self.user2 = utils.create_user() self.category = utils.create_category() self.topic = utils.create_topic(self.category) self.topic2 = utils.create_topic(self.category, user=self.user) self.topic_unread = TopicUnread.objects.create(user=self.user, topic=self.topic) self.topic_unread2 = TopicUnread.objects.create(user=self.user, topic=self.topic2) self.topic_unread3 = TopicUnread.objects.create(user=self.user2, topic=self.topic)
def remove(user_id, name): utils.create_user(user_id) path = f"data/{user_id}/links.json" with open(path, "r") as f: data = json.load(f) if name not in data: raise ValueError("Invalid command: link name not found.") data.pop(name, None) with open(path, "w") as f: json.dump(data, f, indent=4) return "Your link was removed successfully!"
def clear(user_id, group_id=None): utils.create_user(user_id) path = f"data/{user_id}/shopping.json" if group_id is not None: utils.verify_shopgroup(user_id, group_id) path = f"data/shopgroups/{group_id}.json" with open(path, "w") as f: f.write("{}") return show_list(user_id, group_id)
def test_add_user(self): try: utils.create_user( self.client, 'test123', 'test123', '*****@*****.**', self.p1.id, self.d1.id) except: self.fail('Unexpected exception raised: ' 'utils.create_user(' 'self.client, \'test123\', \'test123\',' '\'[email protected]\', self.p1.id,' 'self.d1.id)')
def setUp(self): cache.clear() self.user = utils.create_user() self.user2 = utils.create_user() self.category = utils.create_category() self.topic = utils.create_topic(self.category) self.comment = utils.create_comment(topic=self.topic) self.topic_notification = TopicNotification.objects.create(user=self.user, topic=self.topic, comment=self.comment, is_active=True, action=COMMENT, is_read=True) self.topic_notification2 = TopicNotification.objects.create(user=self.user2, topic=self.topic, comment=self.comment, is_active=True, action=COMMENT, is_read=True)
def create(request): values = {} if request.META["REQUEST_METHOD"] == "POST": valid, error = utils.check_auth_token(request.POST['username']) if valid: utils.create_user(request.POST['username'], request.POST['password'], request.POST['google_wave_address']) values['user_created'] = True else: values['token_failed'] = True values['error'] = error if 'user_created' not in values: values['token'] = utils.create_token() return render_to_response('create.html', values)
def login(): from werkzeug.security import check_password_hash from werkzeug.security import generate_password_hash username = bleach.clean(request.form['username'], tags=[]) password = request.form['password'] if not username: return redirect('/error/empty_user') if 'login-button' in request.form: """Attempts to log the user in""" user = db['users'].find_one(username=username) if user is None: return redirect('/error/invalid_credentials') if check_password_hash(user['password'], password): session_login(username) #return redirect('/competitions') return redirect('/competition/1') if 'register-button' in request.form: """Attempts to register a new user""" shell_username = sanitize_name(username) user_found = db['users'].find_one(username=username) shell_found = db['users'].find_one(shell_username=shell_username) if user_found or shell_found: return redirect('/error/already_registered') admin = False userCount = db['users'].count() #if no users, make first user admin if userCount == 0: admin = True new_user = dict(username=username, password=generate_password_hash(password), admin=admin, shell_username=shell_username) db['users'].insert(new_user) create_user(shell_username, password) # Set up the user id for this session session_login(username) #return redirect('/competitions') return redirect('/competition/1') return redirect('/error/invalid_credentials')
def setup(): if not utils.needs_user(): return flask.redirect(flask.url_for('login')) error = None if flask.request.method == 'POST': username = flask.request.form['username'] password = flask.request.form['password'] password_confirm = flask.request.form['password_confirm'] if password == password_confirm: utils.create_user(username, password) flask.flash('User Created') return flask.redirect(flask.url_for('login')) error = "passwords do not match" return flask.render_template('setup.j2', error=error)
def stats(user_id, name, period=90): utils.create_user(user_id) path = f"data/{user_id}/workouts/{name}.json" if not os.path.isfile(path): raise ValueError("Invalid command: this exercise doesn't exist.") with open(path, "r") as f: data = json.load(f) today = dt.datetime.now() days = [] shown_days = [] nums = [] for diff in range(-period + 1, 1): day = today + dt.timedelta(days=diff) day_iso = day.strftime("%Y/%m/%d") days.append(day.strftime("%d/%m/%Y")) shown_days.append(day.strftime("%d %b") if diff % 3 == 0 else "") nums.append(data.get(day_iso, 0)) binary = [1 if x != 0 else 0 for x in nums] streaks = [len(list(g)) for k, g in groupby(binary) if k == 1] max_num = max(nums) max_day = days[nums.index(max_num)] avg = sum(nums) / period yearly = int(avg * 365) workout_days = sum([x != 0 for x in nums]) best_streak = 0 if len(streaks) == 0 else max(streaks) curr_streak = 0 if len(streaks) == 0 else streaks[-1] msg = f""" *{name.title()} stats for the last {period} days* \\* Maximum: {max_num} ({max_day}) \\* Daily average: {avg:.1f} \\* Yearly projected total: {yearly} \\* You've been active {workout_days} days \\* Best activity streak: {best_streak} \\* Current activity streak: {curr_streak} """ figure = plt.gcf() figure.set_size_inches(16, 9) plt.xticks(rotation=45, ha="right") plt.bar(range(period), nums, align="center", alpha=0.8) plt.xticks(range(period), shown_days) plt.title(name.title()) buf = BytesIO() plt.savefig(buf, format="png", dpi=100, bbox_inches="tight") buf.seek(0) plt.close() return buf, msg
def setUp(self): fss.remove_tree(settings.MEDIA_ROOT) check_permissions() set_site(self.live_server_url) self.browser = Browser() self.browser.visit(self.live_server_url) login_url = settings.LOGIN_URL self.browser.click_link_by_partial_href(login_url) username = '******' password = '******' create_user(username) login( self.browser, username, password, ) upload_url = reverse('documents.views.add_document') self.browser.click_link_by_partial_href(upload_url) source = 'local' docfile = get_abs_path('doctest.pdf') language = 'eng' public = True title = 'test' notes = 'test notes' upload( self.browser, source, docfile, language, public, title, notes, ) self.browser.is_element_not_present_by_value('ready', 10) tag = 'tag' add_tag( self.browser, tag, ) self.tag = tag self.tag_obj = get_tag(tag)
def remove(user_id, to_remove, group_id=None): utils.create_user(user_id) path = f"data/{user_id}/shopping.json" if group_id is not None: utils.verify_shopgroup(user_id, group_id) path = f"data/shopgroups/{group_id}.json" with open(path, "r") as f: current = json.load(f) for name in to_remove: current.pop(name, None) with open(path, "w") as f: json.dump(current, f, indent=4) return show_list(user_id, group_id)
def add(user_id, to_buy, group_id=None): utils.create_user(user_id) path = f"data/{user_id}/shopping.json" if group_id is not None: utils.verify_shopgroup(user_id, group_id) path = f"data/shopgroups/{group_id}.json" with open(path, "r") as f: current = json.load(f) for name, amt in to_buy.items(): current[name] = current.get(name, 0) + amt with open(path, "w") as f: json.dump(current, f, indent=4) return show_list(user_id, group_id)
def create_shopgroup(user_id, group_id, password): utils.create_user(user_id) path_dir = "data/shopgroups" path_dir_info = "data/shopgroup_info" path = f"{path_dir}/{group_id}.json" path_info = f"{path_dir_info}/{group_id}.json" if os.path.isfile(path): raise ValueError("Invalid command: a shopgroup with this name already exists.") os.makedirs(path_dir, exist_ok=True) os.makedirs(path_dir_info, exist_ok=True) utils.create_json_dict(path) utils.create_json_list(path_info) utils.update_shopgroup_list(group_id, password) utils.add_user_to_shopgroup(user_id, group_id) return f"Shopgroup {group_id} was successfully created!"
def get(self): """ Return info about current logged in user Automatically create internal user models for admin google users. """ user = utils.get_current_user() if not user: google_user = users.get_current_user() if not google_user: self.error(403) return if users.is_current_user_admin(): user = utils.create_user(google_user) else: self.error(401) return data = user.to_struct() data['is_admin'] = users.is_current_user_admin() self.response.headers['Content-Type'] = 'application/json; charset=utf-8' self.response.headers['Access-Control-Allow-Origin'] = '*' self.response.out.write(json.dumps(data))
def test_ascii_password(self): for password in chunked_ascii(): self.email = "*****@*****.**" % (uuid.uuid4().hex) self.password = password self.username = create_user(self.email, self.password, self) self.setBasicAuth(self.username, self.password) basic_sync(self.email, self.password, self)
def test_topic_notification_ajax_order(self): """ order by is_read=False first then by date """ user = utils.create_user() for _ in xrange(10): topic = utils.create_topic(self.category, user=user) comment = utils.create_comment(topic=topic, user=user) TopicNotification.objects.create(user=self.user, topic=topic, comment=comment, is_active=True, action=COMMENT) TopicNotification.objects.filter(user=self.user).update(is_read=True) old_date = timezone.now() - datetime.timedelta(days=10) TopicNotification.objects.filter(pk=self.topic_notification.pk).update( is_read=False, date=old_date) utils.login(self) response = self.client.get(reverse('spirit:topic-notification-ajax'), HTTP_X_REQUESTED_WITH='XMLHttpRequest') res = json.loads(response.content) self.assertFalse(res['n'][0]['is_read']) self.assertTrue(res['n'][1]['is_read'])
def test_it(self): from netprintbox.views import setup_guide request1 = testing.DummyRequest() request1.session['netprintbox.dropbox_user.key'] = 'key' with self.assertRaises(exc.HTTPUnauthorized): setup_guide(request1) user = create_user() request2 = testing.DummyRequest() request2.session['netprintbox.dropbox_user.key'] = str(user.key()) response2 = setup_guide(request2) self.assertEqual(response2.status_int, 200) self.assertRegexpMatches(response2.body, re.compile('Step1')) # fall back to step1 if login failed. request3 = testing.DummyRequest() request3.session['netprintbox.dropbox_user.key'] = str(user.key()) response3 = setup_guide(request3) self.assertEqual(response3.status_int, 200) self.assertRegexpMatches(response3.body, re.compile('Step1')) # login succeed. request4 = testing.DummyRequest() request4.session['netprintbox.dropbox_user.key'] = str(user.key()) response4 = setup_guide(request4) self.assertEqual(response4.status_int, 200) self.assertRegexpMatches(response4.body, re.compile('Step2'))
def test_treat_errors_on_netprint_sync(self): user = create_user() file_info = create_file_info(user, path=u'/A4/テスト.doc') service = self._getOUT(user) class dropbox(object): @staticmethod def list(path, recursive=None): root_dir = app_dir() for dir in root_dir['contents']: if dir['path'] == u'/A4': a4_dir = dir break else: self.fail('No A4 directory') a4_dir['contents'].append( create_dropbox_item( path=file_info.path)) return root_dir class netprint(object): @staticmethod def list(): return [create_netprint_item( name=file_info.as_netprint_name(True), error=True)] service.dropbox = dropbox service.netprint = netprint service.sync()
def setUp(self): """Setting up test.""" self.server_url = self.conf_get("main", "url") self.email = "*****@*****.**" % (uuid.uuid4().hex) self.password = "******" self.username = create_user(self.email, self.password, self) self.setBasicAuth(self.username, self.password)
def _test_metadata(self, expected_exception, status, reason, how_many_messages=0): from dropbox.rest import ErrorResponse class client(object): def __init__(self, status, reason): self.status = status self.reason = reason def metadata(self, path): class http_resp(object): status = self.status reason = self.reason @staticmethod def read(): return '' raise ErrorResponse(http_resp) user = create_user() service = self._getOUT(user) service.client = client(status, reason) request = testing.DummyRequest() self.setUpPyramid(request=request) with self.assertRaises(expected_exception): service.list('/') sent_messages = self.mail_stub.get_sent_messages(to=user.email) self.assertEqual(len(sent_messages), how_many_messages)
def _test_session_error(self, method_name, *args): from dropbox.rest import ErrorResponse from netprintbox.exceptions import BecomePendingUser from netprintbox.settings import SYSADMIN_ADDRESS class FakeClient(object): def __getattr__(self, name): class http_resp(object): status = 401 reason = 'Unauthorized' @staticmethod def read(): return '' raise ErrorResponse(http_resp) user = create_user() service = self._getOUT(user) service.client = FakeClient() request = testing.DummyRequest() self.setUpPyramid(request=request) self.assertFalse(user.is_pending) with self.assertRaises(BecomePendingUser): getattr(service, method_name)(*args) self.assertTrue(user.is_pending) sent_messages = self.mail_stub.get_sent_messages(to=user.email) self.assertEqual(len(sent_messages), 1) message = sent_messages[0] message_body = str(message.body) self.assertIn(request.route_url('authorize'), message_body) self.assertIn(SYSADMIN_ADDRESS, message.sender)
def test_comment_undelete(self): """ comment undelete """ self.user = utils.create_user(is_moderator=True) comment = utils.create_comment(user=self.user, topic=self.topic, is_removed=True) utils.login(self) form_data = {} response = self.client.post( reverse('spirit:comment-undelete', kwargs={ 'pk': comment.pk, }), form_data) expected_url = comment.get_absolute_url() self.assertRedirects(response, expected_url, status_code=302, target_status_code=302) response = self.client.get( reverse('spirit:comment-undelete', kwargs={ 'pk': comment.pk, })) self.assertEqual(response.status_code, 200)
def test_email_change(self): """ email change """ user = utils.create_user(password="******") form_data = {'email': '*****@*****.**', 'password': '******'} form = EmailChangeForm(data=form_data, user=user) self.assertEqual(form.is_valid(), True)
def setUp(self): cache.clear() self.user = utils.create_user() self.category = utils.create_category() self.topic = utils.create_topic(category=self.category, user=self.user) for _ in xrange(settings.ST_COMMENTS_PER_PAGE * 4): # 4 pages utils.create_comment(user=self.user, topic=self.topic)
def test_user_mods(self): """ List of admins """ mod = utils.create_user(is_moderator=True) utils.login(self) response = self.client.get(reverse('spirit:admin-user-mods')) self.assertQuerysetEqual(response.context['users'], map(repr, [mod, ]))
def test_get_collections(self): self.email = "*****@*****.**" % (uuid.uuid4().hex) self.password = "******" self.username = create_user(self.email, self.password, self) self.setBasicAuth(self.username, self.password) # The description should be set in the configuration file get_collection_info(self.email, "passowrd", self)
def create_user_interact(request): username = request.POST.get('username') password = request.POST.get('password') tmp = User.objects.filter(username = username) try: if len(tmp) < 1: utils.create_user(username, username, password) nextUrl = reverse('mine.views.login_view') return HttpResponseRedirect(nextUrl) else: data_dict = {} data_dict['occupy'] = 'true' return render(request, 'create_user.html', data_dict) except: data_dict = {} data_dict['occupy'] = 'true' return render(request, 'create_user.html', data_dict)
def setUp(self): cache.clear() self.user = utils.create_user() self.category = utils.create_category() self.topic = utils.create_topic(category=self.category, user=self.user) utils.create_comment(topic=self.topic) utils.create_comment(topic=self.topic) utils.create_comment(topic=self.topic)
def test_user_unactive(self): """ List of unactive """ unactive = utils.create_user() User.objects.filter(pk=unactive.pk).update(is_active=False) utils.login(self) response = self.client.get(reverse('spirit:admin-user-unactive')) self.assertQuerysetEqual(response.context['users'], map(repr, [unactive, ]))
def setUp(self): super(AuthorizeCallbackHandlerTest, self).setUp() self.user = create_user() # mockout import netprintbox.service mock('netprintbox.service.DropboxService.setup_user', returns=self.user)
def post(self): username = self.request.get('username') password = self.request.get('password') verify = self.request.get('verify') email = self.request.get('email') errors = utils.signup_errors(username, password, verify) if any(errors): self.render('/templates/signup.html', username=username, email=email, username_error=errors[0], password_error=errors[1], verify_error=errors[2]) else: utils.create_user(username, password, email) self.set_cookie(username) self.redirect('/')
def test_create_user(self): assert utils.create_user(self._test_user, self._test_user_email, \ self._test_user_password, self._test_user_role) user = utils.get_user(self._test_user) assert user != None assert user['username'] == self._test_user assert user['email'] == self._test_user_email assert user['role'] == self._test_user_role assert utils.delete_user(self._test_user)
def setUp(self): cache.clear() self.user = utils.create_user() self.topic = utils.create_topic(utils.create_category()) for _ in xrange(300): utils.create_comment(user=self.user, topic=self.topic) self.queryset = Comment.objects.all()
def test_resend_activation_email(self): """ resend activation """ user = utils.create_user(email="*****@*****.**") form_data = {'email': '*****@*****.**', } form = ResendActivationForm(form_data) self.assertTrue(form.is_valid()) self.assertEqual(form.get_user(), user)
def create_user(): try: redis = get_redis_connection() username = raw_input('Username: '******'Password: '******' (confirm): ') if password_confirm == password: break else: print('Passwords do not match... Try again...') role = raw_input('Role: ').strip() # create role if needed if not redis.get(schema.ROLES.format(role)): utils.create_role(role) utils.create_user(username=username, password=password, role=role, active=True) print('User created/updated successfully...') except KeyboardInterrupt: pass