def do_adduser_groupchat_room_test():
# create user for test
test_users = []
for i in range(0, 5):
test_user = ('test' + str(i), 'test' + str(i) + '@test.com',
'1234qwer')
utils.delete_user(test_user[0])
utils.sign_up_success(test_user[0], test_user[1], test_user[2])
test_users.append(test_user)
#the first user makes groupchat room with others
auth = (test_users[0][0], test_users[0][2])
utils.post_groupchat_rooms_success(test_users)
#get check from each user that they are put in room
for i in range(0, 5):
roomid = utils.get_groupchat_rooms_success(test_users[i])
#create more users
test_users = []
for i in range(5, 10):
test_user = ('test' + str(i), 'test' + str(i) + '@test.com',
'1234qwer')
utils.delete_user(test_user[0])
utils.sign_up_success(test_user[0], test_user[1], test_user[2])
test_users.append(test_user)
#add new users to original room
utils.addusers_groupchat_rooms_success(test_users, auth, roomid)
print("adding more users to existing groupchat room success\n")
def test_login_success():
query = "{login(email:\"" + email + "\", password: \"123\") {email, token}}"
r = requests.get("{}/graphql?query={}".format(url,
urllib.parse.quote(query)))
delete_user(email)
assert r.status_code == 200
def do_schedule_test():
print("schedule test starts...\n")
# create users for test
test_users = []
print("1.creating 10 users... user test0 to test9\n")
for i in range(0, 10):
test_user = ('test' + str(i), 'test' + str(i) + '@test.com',
'1234qwer')
utils.delete_user(test_user[0])
utils.sign_up_success(test_user[0], test_user[1], test_user[2])
test_users.append(test_user)
# schedule test
print("\n2. test posting schedule by each user.")
now = datetime.datetime.now()
start = now
end = now + datetime.timedelta(hours=1)
start = time.mktime(start.timetuple()) * 1000
end = time.mktime(end.timetuple()) * 1000
detail = "test"
for user in test_users:
post_schedule_success((user[0], user[2]), start, end, detail)
print("\n3. test getting schedules by each user.")
for user in test_users:
get_schedules_success((user[0], user[2]))
print('schedule test success')
def do_post_delete_test():
test_user1 = ('test1', '*****@*****.**', '1234qwer')
test_user2 = ('test2', '*****@*****.**', '1234qwer')
# post user which will be used for test
utils.delete_user(test_user1[0])
utils.delete_user(test_user2[0])
utils.sign_up_success(test_user1[0], test_user1[1], test_user1[2])
utils.sign_up_success(test_user2[0], test_user2[1], test_user2[2])
# post postings for test
post_text = 'text'
post1_0 = utils.posting_success(test_user1[0], test_user1[2], post_text)
post1_1 = utils.posting_success(test_user1[0], test_user1[2], post_text)
post1_2 = utils.posting_success(test_user1[0], test_user1[2], post_text)
# delete & put fail test
utils.post_delete_fail((test_user2[0], test_user2[2]),
post1_0.json()['id'])
utils.post_put_fail((test_user2[0], test_user2[2]), post1_0.json()['id'])
# delete & put success test
utils.post_delete_success((test_user1[0], test_user1[2]),
post1_1.json()['id'])
utils.post_put_success((test_user1[0], test_user1[2]),
post1_2.json()['id'])
print('post delete test success')
def do_wall_poll_post_test():
#create test user
test_users = []
for i in range(0, 2):
username = '******' + str(i)
test_user = ( username, username + '@test.com', '1234qwer' )
utils.delete_user( test_user[0] )
utils.sign_up_success( test_user[0], test_user[1], test_user[2] )
test_users.append( test_user )
# poll post fail because they are not friend
utils.post_wall_poll_fail( (test_users[0][0], test_users[0][2]), test_users[1][0], 'test0 posts this posting' )
utils.post_wall_poll_fail( (test_users[1][0], test_users[1][2]), test_users[0][0], 'test1 posts this posting' )
# make friend..
utils.post_friendrequest( ( test_users[0][0], test_users[0][2] ), test_users[1][0] )
request_id=[]
request_id.append(0)
request_id.append( utils.get_friendrequest( (test_users[1][0], test_users[1][2]), test_users[0][0] ) )
utils.accept_friendrequest( ( test_users[1][0], test_users[1][2]), request_id[1] )
# poll post success because they are friend
utils.post_wall_poll_success( (test_users[0][0], test_users[0][2]), test_users[1][0], 'test0 posts this posting' )
utils.post_wall_poll_success( (test_users[1][0], test_users[1][2]), test_users[0][0], 'test1 posts this posting' )
def do_user_delete_success_test(userNum):
for i in range(0, userNum):
username = "******" + str(i)
utils.delete_user(username)
print('delete user by sns_admin success\n')
def do_get_messages_test():
# create users for test
test_users = []
for i in range(0, 4):
test_user = ('test' + str(i), 'test' + str(i) + '@test.com',
'1234qwer')
utils.delete_user(test_user[0])
utils.sign_up_success(test_user[0], test_user[1], test_user[2])
test_users.append(test_user)
# create room for test
url = urls.chatroomlist_url()
auth = (test_users[0][0], test_users[0][2])
data = {'user2': test_users[1][0]}
res = requests.post(url, data, auth=auth)
roomid = res.json()['id']
# test
for i in range(0, 2):
utils.get_chat_messages_success((test_users[i][0], test_users[i][2]),
roomid)
for i in range(2, 4):
utils.get_chat_messages_fail((test_users[i][0], test_users[i][2]),
roomid)
def do_put_password_test():
# create test user
test_user = ('test0', '*****@*****.**', '1234qwer')
utils.delete_user(test_user[0])
utils.sign_up_success(test_user[0], test_user[1], test_user[2])
# put password test
utils.put_password_success((test_user[0], test_user[2]))
def test_userConfirm_success():
signup(email)
uniqid = "randomUniqid"
query = " {userConfirm(email: \"" + email + "\", uniqid: \"" + uniqid + "\")}"
r = requests.get("{}/graphql?query={}".format(url,
urllib.parse.quote(query)))
assert len(r.json()['errors']) == 1
assert r.json()['errors'][0]['message'] == "Link is not correct"
delete_user(email)
def test_add_and_view_buttons(self):
register_user(self.browser)
self.assertTrue(
exists_by_xpath(self.browser, '//button[text()="Add"]')
)
self.assertTrue(
exists_by_xpath(self.browser, '//a[text()="View expenses"]')
)
delete_user(self.browser)
def test_user_exists_error(self):
register_user(self.browser)
# Force Selenium to wait until the new user has been created.
get_flashed_message(self.browser)
register_user(self.browser, should_fail=True)
message = get_flashed_message(self.browser)
self.assertEqual(message, 'Username already exists.')
# Delete. First user would have been created.
delete_user(self.browser)
def test_new_user_categories(self):
register_user(self.browser)
elem = wait_until(self.browser, '//select[@name="category_id"]')
select = Select(elem)
for option in select.options:
if option.text == '(category)':
self.assertTrue(option.text not in DEFAULT_CATEGORIES)
else:
self.assertTrue(option.text.lower() in DEFAULT_CATEGORIES)
delete_user(self.browser)
def test_userConfirm_success():
signup(email)
user = Users.find_one({"email": email})
uniqid = user['is_check']['id']
query = " {userConfirm(email: \"" + email + "\", uniqid: \"" + uniqid + "\")}"
r = requests.get("{}/graphql?query={}".format(url,
urllib.parse.quote(query)))
assert r.status_code == 200
assert r.json()['data']['userConfirm'] == True
delete_user(email)
def do_post_image_test():
# create test user
test_user = ('test0', '*****@*****.**', '1234qwer')
utils.delete_user(test_user[0])
utils.sign_up_success(test_user[0], test_user[1], test_user[2])
# post image test
utils.post_image_success((test_user[0], test_user[2]))
print('post image test success')
def do_sign_up_post_suceess_test(userNum):
for i in range(0, userNum):
username = "******" + str(i)
email = "test" + str(i) + "@naver.com"
password = "******"
utils.delete_user(username)
utils.sign_up_success(username, email, password)
print("sign up test success\n")
def do_post_groupchat_rooms_test():
# create user for test
test_users = []
for i in range(0, 5):
test_user = ('test' + str(i), 'test' + str(i) + '@test.com',
'1234qwer')
utils.delete_user(test_user[0])
utils.sign_up_success(test_user[0], test_user[1], test_user[2])
test_users.append(test_user)
#the first user will make groupchat room with others
utils.post_groupchat_rooms_success(test_users)
print("posting groupchat room success\n")
def do_image_censor_test():
# create test user
print("1. create a user: test0")
test_user = ('test0', '*****@*****.**', '1234qwer')
utils.delete_user(test_user[0])
utils.sign_up_success(test_user[0], test_user[1], test_user[2])
# image censor test
print("\n2. test setting profile image success with safe images.")
post_image_success((test_user[0], test_user[2]))
print("\n3. test banning profile image with unsafe images.")
post_image_fail((test_user[0], test_user[2]))
print('image censor test success')
def do_get_chat_rooms_test():
# create user for test
test_users = []
for i in range(0, 20):
test_user = ('test' + str(i), 'test' + str(i) + '@test.com',
'1234qwer')
utils.delete_user(test_user[0])
utils.sign_up_success(test_user[0], test_user[1], test_user[2])
test_users.append(test_user)
for i in range(0, 20):
utils.get_chat_rooms_success((test_users[i][0], test_users[i][2]))
for i in range(0, 20):
utils.get_chat_rooms_fail((test_users[i][0], '1234'))
def do_friend_test():
print("friend test starts...\n")
# create user for test
test_users = []
print("1.creating 10 users... user test0 to test9\n")
for i in range(0, 10):
test_user = ( 'test' + str(i), 'test' + str(i) + '@test.com', '1234qwer' )
utils.delete_user( test_user[0] )
utils.sign_up_success( test_user[0], test_user[1], test_user[2] )
test_users.append(test_user)
print("2.user test0 sends friend request to 9 users by POST\n")
auth = (test_users[0][0], test_users[0][2])
for i in range(1, 10):
post_friendrequest( auth, test_users[i][0])
print("3.users check friendrequests from test0 by GET\n")
request_id=[]
request_id.append(0)
for i in range(1, 10):
auth = (test_users[i][0], test_users[i][2])
request_id.append( get_friendrequest( auth, test_users[0][0]) )
print("4.user test1~ test3 decline the request from test0 by DELETE\n")
for i in range(1, 4):
auth = (test_users[i][0], test_users[i][2])
delete_friendrequest( auth, request_id[i])
print("5.user test0 tries to accept request(fail is correct) by PATCH")
for i in range(4, 10):
auth = (test_users[0][0], test_users[0][2])
accept_friendrequest( auth, request_id[i])
print("6.user test4~9 accept request by PATCH")
for i in range(4, 10):
auth = (test_users[i][0], test_users[i][2])
accept_friendrequest( auth, request_id[i])
print("7.all users get myfriend list by GET")
friend_id=[]
for i in range(0, 10):
auth = (test_users[i][0], test_users[i][2])
friend_id.append(get_myfriend( auth ))
print("8.user test4~6 unfriend with test0 by PATCH")
for i in range(4, 7):
auth = (test_users[i][0], test_users[i][2])
delete_myfriend(auth, test_users[0][0], friend_id[i])
print("9.user test0 unfriend with test7~9 by PATCH")
for i in range(7, 10):
auth = (test_users[0][0], test_users[0][2])
delete_myfriend(auth, test_users[i][0], friend_id[i])
print("Friend Test Succeeded without error")
def do_get_groupchat_rooms_test():
# create user for test
test_users = []
for i in range(0, 5):
test_user = ('test' + str(i), 'test' + str(i) + '@test.com',
'1234qwer')
utils.delete_user(test_user[0])
utils.sign_up_success(test_user[0], test_user[1], test_user[2])
test_users.append(test_user)
#the first user makes groupchat room with others
utils.post_groupchat_rooms_success(test_users)
#get check from each user that they are put in room
for i in range(0, 5):
utils.get_groupchat_rooms_success(test_users[i])
print("get groupchat room success\n")
def do_timeline_permission_test():
#create test user
test_users = []
for i in range(0, 2):
username = '******' + str(i)
test_user = (username, username + '@test.com', '1234qwer')
utils.delete_user(test_user[0])
utils.sign_up_success(test_user[0], test_user[1], test_user[2])
test_users.append(test_user)
utils.posting_success(test_users[0][0], test_users[0][2],
'test0 posts this posting')
utils.posting_success(test_users[1][0], test_users[1][2],
'test1 posts this posting')
postList = requests.get(urls.posts_url(),
auth=(test_users[1][0], test_users[1][2]))
for post in postList.json():
if post['user'] == test_user[0][0]:
print(
'error: test1 can access post by test0 who is not friend of him.'
)
utils.post_friendrequest((test_users[0][0], test_users[0][2]),
test_users[1][0])
request_id = []
request_id.append(0)
request_id.append(
utils.get_friendrequest((test_users[1][0], test_users[1][2]),
test_users[0][0]))
utils.accept_friendrequest((test_users[1][0], test_users[1][2]),
request_id[1])
postList = requests.get(urls.posts_url(),
auth=(test_users[1][0], test_users[1][2]))
friendPostShow = False
for post in postList.json():
# print( post )
if post['user'] == test_users[0][0]:
friendPostShow = True
if not friendPostShow:
print('error: test1 cannot access post by test0 who is his friend')
exit(1)
def test_form_fields(self):
register_user(self.browser)
input_ = self.browser.find_element_by_xpath('//input[@name="cost"]')
self.assertEqual(input_.get_attribute('placeholder'), 'Cost ($)')
select = Select(
self.browser.find_element_by_xpath('//select[@name="category_id"]')
)
self.assertEqual(select.first_selected_option.text, '(category)')
input_ = self.browser.find_element_by_xpath('//input[@name="comment"]')
self.assertEqual(input_.get_attribute('placeholder'), 'Comment')
input_ = self.browser\
.find_element_by_xpath('//input[@name="discretionary"]')
self.assertEqual(input_.get_attribute('checked'), 'true')
delete_user(self.browser)
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 do_login_fail_test(userNum):
# by wrong username
for i in range(20, 30):
username = "******" + str(i)
password = "******"
utils.delete_user(username)
utils.login_fail(username, password)
print("login fail by username test success\n")
# by wrong password
for i in range(0, userNum):
username = "******" + str(i)
password = "******"
utils.login_fail(username, password)
print("login fail by password test success\n")
def do_post_groupchat_messages_test():
test_users = []
for i in range(0, 5):
test_user = ('test' + str(i), 'test' + str(i) + '@test.com',
'1234qwer')
utils.delete_user(test_user[0])
utils.sign_up_success(test_user[0], test_user[1], test_user[2])
test_users.append(test_user)
#the first user makes groupchat room with others
utils.post_groupchat_rooms_success(test_users)
#the first user get the id of the room
roomid = utils.get_groupchat_rooms_success(test_users[0])
#each user posts a message to that room
for i in range(0, 5):
utils.post_groupchat_messages_success(
(test_users[i][0], test_users[i][2]), roomid)
print("post message to groupchat room success")
def do_exit_groupchat_room_test():
# create user for test
test_users = []
for i in range(0, 5):
test_user = ('test' + str(i), 'test' + str(i) + '@test.com',
'1234qwer')
utils.delete_user(test_user[0])
utils.sign_up_success(test_user[0], test_user[1], test_user[2])
test_users.append(test_user)
#the first user will make groupchat room with others
utils.post_groupchat_rooms_success(test_users)
#get the room id
roomid = utils.get_groupchat_rooms_success(test_users[0])
#the every user exits from the room
for i in range(0, 5):
auth = (test_users[i][0], test_users[i][2])
utils.exit_groupchat_rooms_success(roomid, auth)
print("deleting users from existing groupchat room success\n")
def test_toggle_user(self):
assert utils.create_user(self._test_user, password=self._test_user_password, role=self._test_user_role)
assert utils.toggle_user(self._test_user, False)
user = utils.get_user(self._test_user)
assert user != None
assert user['enabled'] == False
assert utils.toggle_user(self._test_user, True)
user = utils.get_user(self._test_user)
assert user != None
assert user['enabled'] == True
assert utils.delete_user(self._test_user)
def users():
if utils.needs_user():
return flask.redirect(flask.url_for('setup'))
if ('logged_in' not in flask.session) or (not flask.session['logged_in']):
return flask.redirect(flask.url_for('login'))
error = None
if flask.request.method == 'POST':
if "delete" in flask.request.form:
if len(utils.get_users()) > 1:
user_id = int(flask.request.form['id'])
utils.delete_user(user_id)
flask.flash('User Deleted')
else:
flask.flash("can not delete last user")
else:
username = flask.request.form['username']
user = utils.get_user(username)
if (not user) or ("edit" in flask.request.form):
password = flask.request.form['password']
password_confirm = flask.request.form['password_confirm']
if password == password_confirm:
if "edit" in flask.request.form:
user_id = int(flask.request.form['edit'])
utils.modify_user(user_id, username, password)
flask.flash('User Edited')
else:
utils.create_user(username, password)
flask.flash('User Created')
if "setup" in flask.request.form:
return flask.redirect(flask.url_for('login'))
else:
error = "passwords do not match"
else:
error = "user already exists"
users = utils.get_users()
return flask.render_template(
'users.j2',
users=users,
error=error)
def do_friend_request_test():
# create users for test
test_users = []
for i in range(0, 10):
test_user = ('test' + str(i), 'test' + str(i) + '@test.com',
'1234qwer')
utils.delete_user(test_user[0])
utils.sign_up_success(test_user[0], test_user[1], test_user[2])
test_users.append(test_user)
#each first five user sends friend request to other 5 users
for i in range(0, 5):
auth = (test_users[i][0], test_users[i][2])
for j in range(5, 10):
user = (test_users[j][0])
post_friend_request_success(auth, user)
#request - back => try already existent request
for i in range(5, 10):
auth = (test_users[i][0], test_users[i][2])
for j in range(0, 5):
user = (test_users[j][0])
post_friend_request_success(auth, user)
#othef 5 users get the request and accept request
#fail test first - name change needed
for i in range(0, 5):
auth = (test_users[i][0], test_users[i][2])
for j in range(5, 10):
user = (test_users[j][0])
requestid = get_friend_request_success(auth, user)
print(requestid)
accept_friend_request_success(auth, requestid)
#friend request sender cannot accept => test add
for i in range(5, 10):
auth = (test_users[i][0], test_users[i][2])
for j in range(0, 5):
user = (test_users[j][0])
requestid = get_friend_request_success(auth, user)
print(requestid)
accept_friend_request_success(auth, requestid)
def post(self):
self.login()
if self.request.get('action') == 'Delete Account':
if self.request.get('delete_account'):
from utils import delete_user
from urllib import urlencode
delete_user(self.user_key.id_or_name())
self.session.terminate()
self.redirect('/?%s' % urlencode({'notify' : 'Account deleted'}))
return
else:
self.action_feedback.append({'class' : 'error', 'message' : 'Please verify that you want to delete this account by ticking the checkbox'})
elif self.request.get('action') == 'Unlink Account':
from google.appengine.api.users import User
accounts = self.request.get_all('linked_account')
todel = []
for acc in accounts:
todel.append(db.Query(models.GoogleLogin, keys_only=True).filter('user ='******'google_user ='******'class' : 'notify', 'message' : 'Unlinked %s' % acc})
db.delete(todel)
elif self.request.get('action') == 'Change Password':
from common import get_hash
current_password_hash = get_hash(self.request.get('current_password', ''))
new_password_hash = get_hash(self.request.get('new_password', ''))
verify_new_password_hash = get_hash(self.request.get('verify_new_password', ''))
login = db.Query(models.Login).filter('username ='******'password_hash =', current_password_hash).get()
if login is None:
self.action_feedback.append({'class' : 'error', 'message' : 'Wrong password'})
elif new_password_hash != verify_new_password_hash:
self.action_feedback.append({'class' : 'error', 'message' : 'Provided passwords don\' match'})
else:
login.password_hash = new_password_hash
login.put()
self.action_feedback.append({'class' : 'notify', 'message' : 'Password changed'})
linked_accounts = db.Query(models.GoogleLogin).filter('user ='******'linked_accounts'] = [a.google_user.email() for a in linked_accounts]
self.render_page('SettingsPage.html')
def users():
if utils.needs_user():
return flask.redirect(flask.url_for('setup'))
if ('logged_in' not in flask.session) or (not flask.session['logged_in']):
return flask.redirect(flask.url_for('login'))
error = None
if flask.request.method == 'POST':
if "delete" in flask.request.form:
if len(utils.get_users()) > 1:
user_id = int(flask.request.form['id'])
utils.delete_user(user_id)
flask.flash('User Deleted')
else:
flask.flash("can not delete last user")
else:
username = flask.request.form['username']
user = utils.get_user(username)
if (not user) or ("edit" in flask.request.form):
password = flask.request.form['password']
password_confirm = flask.request.form['password_confirm']
if password == password_confirm:
if "edit" in flask.request.form:
user_id = int(flask.request.form['edit'])
utils.modify_user(user_id, username, password)
flask.flash('User Edited')
else:
utils.create_user(username, password)
flask.flash('User Created')
if "setup" in flask.request.form:
return flask.redirect(flask.url_for('login'))
else:
error = "passwords do not match"
else:
error = "user already exists"
users = utils.get_users()
return flask.render_template('users.j2', users=users, error=error)
def do_get_friend_test():
#create test user
test_users = []
for i in range(0, 2):
username = '******' + str(i)
test_user = ( username, username + '@test.com', '1234qwer' )
utils.delete_user( test_user[0] )
utils.sign_up_success( test_user[0], test_user[1], test_user[2] )
test_users.append( test_user )
# test0 doesn't have test1 as friend
friends = utils.get_friends_success( (test_users[0][0], test_users[0][2]) )
for friend in friends.json():
if friend['username'] == test_users[1][0]:
print('error: {0} has {1} as friend'.format(test_users[0][0], test_users[1][0]))
exit(1)
# make friend..
utils.post_friendrequest( ( test_users[0][0], test_users[0][2] ), test_users[1][0] )
request_id=[]
request_id.append(0)
request_id.append( utils.get_friendrequest( (test_users[1][0], test_users[1][2]), test_users[0][0] ) )
utils.accept_friendrequest( ( test_users[1][0], test_users[1][2]), request_id[1] )
# test0 has test1 as friend
friends = utils.get_friends_success( (test_users[0][0], test_users[0][2]) )
hasFriend = False
for friend in friends.json():
if friend['username'] == test_users[1][0]:
hasFriend = True
if not hasFriend:
print('error: {0} does not have {1} as friend'.format(test_users[0][0], test_users[1][0]))
exit(1)
def test_user_ops(self):
test_user = get_random_string()
test_role = get_random_string()
# create
assert utils.create_user(username=test_user, password='******', role=test_role)
assert utils.get_user(test_user) != None
# toggle
assert utils.toggle_user(test_user, False)
user_data = json.loads(utils.get_user(test_user))
assert user_data['enabled'] == False
assert utils.toggle_user(test_user, True)
user_data = json.loads(utils.get_user(test_user))
assert user_data['enabled'] == True
assert utils.toggle_user(test_user)
user_data = json.loads(utils.get_user(test_user))
assert user_data['enabled'] == False
# delete
assert utils.delete_user(test_user)
assert utils.get_user(test_user) == None
assert utils.delete_role(test_role)
def delete_user(username):
try:
utils.delete_user(username)
flash(messages.USER_DELETED, 'success')
except Exception, e:
flash('{0} {1}'.format(messages.ERROR_DELETING_USER, e), 'error')
def tearDown(self):
delete_user(self.browser)
self.browser.quit()
def delete_user(username):
try:
utils.delete_user(username)
flash(messages.USER_DELETED, 'success')
except Exception, e:
flash('{0} {1}'.format(messages.ERROR_DELETING_USER, e), 'error')
def test_success_message(self):
register_user(self.browser)
message = get_flashed_message(self.browser)
self.assertEqual(message, 'Welcome to Slate!')
delete_user(self.browser)
def test_logout(self):
login_user(self.browser)
logout_user(self.browser)
login_user(self.browser)
delete_user(self.browser)
def test_login(self):
login_user(self.browser)
delete_user(self.browser)
def tearDown(self):
if utils.get_user(self._test_user):
utils.delete_user(self._test_user)
def teardown ():
utils.delete_user ("alice")
utils.delete_group ("winsys")
