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