def cleanup_user_by_email(email):
users = fhqtest.admin_session.users({
"onpage": 10,
"page": 0,
"filter_text": email
})
user = None
for usr in users["data"]:
if usr['email'] == email:
user = usr
if usr['created'] == '':
fhqtest.log_err("Field created could not be empty for user #" +
str(usr['id']))
exit(-1)
if user != None:
print("Removing '" + email + "' ...")
user_delete = fhqtest.admin_session.user_delete({
"userid":
user['id'],
"password":
fhqtest.ADMIN_PASSWORD
})
fhqtest.check_response(user_delete,
"User '" + email + "' succesfull removed")
def run_tests():
server_api = fhqtest.admin_session.server_api({})
fhqtest.check_response(server_api, "problem with server_api")
server_info = fhqtest.admin_session.server_info({})
fhqtest.check_response(server_info, "problem with server_info")
stats = {}
all_cmd_count = 0
called_cmd_count = 0
for a in server_api['data']:
cmd = a['cmd']
all_cmd_count = all_cmd_count + 1
stats[cmd] = 0
if cmd in server_info['data']['request_statistics']:
stats[cmd] = server_info['data']['request_statistics'][cmd]
called_cmd_count = called_cmd_count + 1
s = "Command " + cmd + " " + str(stats[cmd]) + " times"
if stats[cmd] == 0:
fhqtest.log_warn(s)
else:
fhqtest.print_success(s)
fhqtest.print_bold("***********\n*API Coverage " +
str(called_cmd_count * 100 / all_cmd_count) +
"%\n***********")
def run_tests():
# Cleanup
fhqtest.print_bold("Clean up test data... ")
ul_list = fhqtest.admin_session.useful_links_list({"filter": ""})
fhqtest.alert(ul_list == None, 'Could not get response')
fhqtest.print_success("Cleaned")
url1 = fhqtest.generate_random(2048)
description1 = fhqtest.generate_random(2048)
author1 = fhqtest.generate_random(127)
# test create game
fhqtest.print_bold("Try create useful_link...")
ul_add = fhqtest.admin_session.useful_links_add({
"url": url1,
"description": description1,
"author": author1,
})
pprint(ul_add)
fhqtest.alert(ul_add == None, 'Could not get response (2)')
fhqtest.check_response(ul_add, "Useful Link succesfull created")
if ul_add['result'] == 'FAIL':
fhqtest.throw_err('Could not create Useful Link')
def run_tests():
leak_uuid1 = uuid.uuid1()
leak1 = None
#cleanup
fhqtest.print_bold("Clean up test data... ")
leaks = fhqtest.admin_session.leaks_list({"page": 0, "onpage": 10})
for leak in leaks["data"]:
fhqtest.admin_session.leaks_delete({"id": leak["id"]})
print("Leak with id #" + str(leak["id"]) + " was succesfully deleted!")
fhqtest.print_success("Cleaned")
#leak creation test
fhqtest.print_bold("Try create leak...")
leak1 = fhqtest.admin_session.leaks_add({
"uuid": str(leak_uuid1),
"game_uuid": fhqtest.GAME_UUID1,
# "gameid": 0,
"name": "test_leak1",
"content": "some_secret_content",
"score": 100
})
fhqtest.alert(leak1 == None, 'Could not get response')
fhqtest.check_response(leak1, "Leak succesfull created")
#leak update test
leak_id = None
leaks = fhqtest.admin_session.leaks_list({"page": 0, "onpage": 10})
for leak in leaks["data"]:
if leak["id"] != '':
leak_id = leak["id"]
else:
fhqtest.log_err("Id could not be empty")
fhqtest.print_bold("Update leak... ")
leak_updt = fhqtest.admin_session.leaks_update({
"id": leak_id,
"name": "test_leak1_new",
})
fhqtest.alert(leak_updt == None, 'Could not get response')
if leak_updt['result'] == 'FAIL':
fhqtest.log_err(leak_updt['error'])
else:
leaks = fhqtest.admin_session.leaks_list({"page": 0, "onpage": 10})
for leak in leaks["data"]:
if leak["id"] == leak_id:
fhqtest.print_bold("Check name after update... ")
if leak["name"] != "test_leak1_new":
fhqtest.log_err("Leak has wrong name")
else:
fhqtest.print_success("Leak has been successfully updated")
else:
fhqtest.log_err("This leak isn't the one we updated!")
print("Id of this leak is #" + str(leak["id"]))
#TODO leaks_list test
#TODO leaks_buy test
def delete_msg(session, req):
res = session.chats_message_delete(req)
pprint(res)
fhqtest.check_response(res, "succesfull deleted")
fhqtest.alert('status' not in res, 'Not member "status"')
return res
def edit_msg(session, req):
res = session.chats_message_edit(req)
pprint(res)
fhqtest.check_response(res, "succesfull edited")
fhqtest.alert('user_id' not in res, 'Not member "user_id"')
fhqtest.alert('message_id' not in res, 'Not member "message_id"')
return res
def send_msg(session, req):
res = session.chats_message_send(req)
pprint(res)
fhqtest.check_response(res, "succesfull sended")
fhqtest.alert(res['message'] != req['message'], '"message" not equal')
fhqtest.alert('user_id' not in res, 'Not member "user_id"')
fhqtest.alert('dt' not in res, 'Not member "dt"')
fhqtest.alert(res['dt'] == '', '"dt" empty')
fhqtest.alert('message_id' not in res, 'Not member "message_id"')
fhqtest.alert('status' not in res, 'Not member "status"')
return res
def read_msg(session, req):
res = session.chats_message_read(req)
pprint(res)
fhqtest.check_response(res, "succesfull readed")
fhqtest.alert('messages' not in res, 'Not member "messages"')
fhqtest.alert(res['chat'] != req['chat'], '"chat" not equal')
fhqtest.alert(len(res['messages']) < 1, '"messages" empty')
fhqtest.alert('message' not in res['messages'][0], 'Not member "messages" in list "messages"')
fhqtest.alert('user' not in res['messages'][0], 'Not member "user" in list "messages"')
fhqtest.alert('dt' not in res['messages'][0], 'Not member "dt" in list "messages"')
return res
def run_tests():
r = fhqtest.admin_session.publiceventslist({"page": 0, "onpage": 10})
if r['count'] > 0:
pass
# TODO remove
event_message = fhqtest.generate_random(50).strip()
event_message_correct = event_message
event_message_correct = event_message_correct.replace('>', '>')
event_message_correct = event_message_correct.replace('<', '<')
event_message_correct = event_message_correct.replace('"', '"')
event_type = "info"
print(event_message)
r_pub_event1 = fhqtest.admin_session.createpublicevent({
"type":
event_type,
"message":
event_message
})
fhqtest.alert(r_pub_event1 == None,
'Could not get response (createpublicevent)')
fhqtest.check_response(r_pub_event1, "Public Event succesfull created")
pprint(r_pub_event1)
time.sleep(1)
# TODO redesign on previus request must return data
r = fhqtest.admin_session.publiceventslist({
"page": 0,
"onpage": 10,
"search": event_message
})
pub_event1 = r['data'][0]
fhqtest.check_values("type of public event", pub_event1['type'],
event_type)
fhqtest.check_values("message of public event", pub_event1['message'],
event_message_correct)
r_event1 = fhqtest.admin_session.getpublicevent(
{"eventid": pub_event1['id']})
fhqtest.alert(r_event1 == None, 'Could not get response (getpublicevent)')
fhqtest.check_response(r_event1, "Public Event succesfull got")
r_event1 = r_event1['data']
fhqtest.check_values("(2) type of public event", r_event1['type'],
event_type)
fhqtest.check_values("(2) message of public event", r_event1['message'],
event_message_correct)
r_event1_removed = fhqtest.admin_session.deletepublicevent(
{"eventid": pub_event1['id']})
fhqtest.alert(r_event1_removed == None,
'Could not get response (deletepublicevent)')
fhqtest.check_response(r_event1_removed, "Public Event succesfull removed")
def run_tests():
fhqtest.print_bold("Try update readonly sett...")
resp = fhqtest.admin_session.server_settings_update({
"name": 'app_version',
"value": '0.0.3'
})
fhqtest.alert(resp['result'] != 'FAIL',
'Wrong response (server_settings_update app_version)')
_settName = 'mail_signature_text'
fhqtest.print_bold("Try get '" + _settName + "' sett...")
server_settings = fhqtest.admin_session.server_settings({})
fhqtest.alert(server_settings == None,
'Could not get response (server_settings)')
fhqtest.check_response(server_settings, "problem with server_settings")
sett = None
for _sett in server_settings['data']:
if _sett['name'] == _settName:
sett = _sett
_oldValue = sett['value']
_newValue = fhqtest.generate_random(1024).strip()
fhqtest.print_bold("Try update '" + _settName + "' sett...")
resp = fhqtest.admin_session.server_settings_update({
"name": _settName,
"value": _newValue
})
fhqtest.alert(resp == None,
'Could not get response (server_settings_update)')
fhqtest.check_response(resp, "request server_settings_update")
# pprint(resp)
# request again all the list
fhqtest.print_bold("Try get again '" + _settName + "' sett...")
server_settings = fhqtest.admin_session.server_settings({})
fhqtest.alert(server_settings == None,
'Could not get response (server_settings)')
fhqtest.check_response(server_settings, "request server_settings")
settUpdated = None
for _sett in server_settings['data']:
if _sett['name'] == _settName:
settUpdated = _sett
_updatedValue = settUpdated['value']
if _updatedValue != _newValue:
fhqtest.throw_err("Expected '" + _newValue + "', but got '" +
_updatedValue + "'")
fhqtest.log_ok("Updated settings success")
def run_tests():
chat_user1 = None
chat_user2 = None
chat_user3 = None
fhqtest.print_bold("Clean up test data... ")
cleanup_user_by_email("chat_user1")
cleanup_user_by_email("chat_user2")
cleanup_user_by_email("chat_user3")
fhqtest.print_success("Cleaning complete")
# test create users
fhqtest.print_bold("Create " + chat_user1_data['email'] + "...")
chat_user1 = fhqtest.admin_session.users_add(chat_user1_data)
fhqtest.check_response(chat_user1,
chat_user1_data['nick'] + " succesfull created")
fhqtest.print_bold("Create " + chat_user2_data['email'] + "...")
chat_user2 = fhqtest.admin_session.users_add(chat_user2_data)
fhqtest.check_response(chat_user2,
chat_user2_data['nick'] + " succesfull created")
fhqtest.print_bold("Create " + chat_user3_data['email'] + "...")
chat_user3 = fhqtest.admin_session.users_add(chat_user3_data)
fhqtest.check_response(chat_user3,
chat_user3_data['nick'] + " succesfull created")
chat_user1_session = None
chat_user2_session = None
chat_user3_session = None
fhqtest.print_bold("Login " + chat_user1_data['email'] + "...")
chat_user1_session = FreeHackQuestClient(fhqtest.TEST_SERVER)
chat_user1_login = chat_user1_session.login({
"email":
chat_user1_data['email'],
"password":
chat_user1_data['password']
})
fhqtest.check_response(chat_user1_login,
chat_user1_data['nick'] + " succesfull loggined")
fhqtest.print_bold("Login " + chat_user2_data['email'] + "...")
chat_user2_session = FreeHackQuestClient(fhqtest.TEST_SERVER)
chat_user2_login = chat_user2_session.login({
"email":
chat_user2_data['email'],
"password":
chat_user2_data['password']
})
fhqtest.check_response(chat_user2_login,
chat_user2_data['nick'] + " succesfull loggined")
fhqtest.print_bold("Login " + chat_user3_data['email'] + "...")
chat_user3_session = FreeHackQuestClient(fhqtest.TEST_SERVER)
chat_user3_login = chat_user3_session.login({
"email":
chat_user3_data['email'],
"password":
chat_user3_data['password']
})
fhqtest.check_response(chat_user3_login,
chat_user3_data['nick'] + " succesfull loggined")
# send + read
send_out_1 = send_msg(chat_user1_session, {
"message": "hello",
"chat": "0"
})
read_out_2 = read_msg(chat_user2_session, {"chat": "0"})
read_out_3 = read_msg(chat_user3_session, {"chat": "0"})
fhqtest.check_values("double reading", read_out_3['messages'],
read_out_2['messages'])
fhqtest.check_values("sended message",
read_out_3['messages'][-1]['message'],
send_out_1['message'])
fhqtest.check_values("sended message",
read_out_2['messages'][-1]['message'],
send_out_1['message'])
# send + read + edit + read
send_out_2 = send_msg(chat_user2_session, {"message": "ho", "chat": "0"})
read_out_3 = read_msg(chat_user3_session, {"chat": "0"})
edit_out_2 = edit_msg(chat_user2_session, {
"message_id": send_out_2["message_id"],
"message_new": "hi"
})
fhqtest.alert(
read_out_3['messages'][-1]['message'] == edit_out_2['message'],
'Equal edited message')
read_out_1 = read_msg(chat_user1_session, {"chat": "0"})
fhqtest.check_values("edited message",
read_out_1['messages'][-1]['message'],
edit_out_2['message'])
# delete + read
cnt_befor = len(read_out_1['messages'])
delete_out_2 = delete_msg(chat_user2_session,
{"message_id": send_out_2["message_id"]})
fhqtest.check_values("Deleting message", delete_out_2['status'], "ok")
read_out_1 = read_msg(chat_user1_session, {"chat": "0"})
fhqtest.check_values("Count message after delete",
len(read_out_1['messages']), cnt_befor - 1)
def run_tests():
# scoreboard
# users
# user
# user_change_password
# user_create
# user_delete
# user_skills
# user_update
user2_session = None
# Cleanup
user1 = None
user2 = None
user3 = None
fhqtest.print_bold("Clean up test data... ")
cleanup_user_by_email("user1")
cleanup_user_by_email("user2")
cleanup_user_by_email("user3")
cleanup_user_by_email("user3_test")
fhqtest.print_success("Cleaning complete")
# test create users
fhqtest.print_bold("Try create " + user1_data['email'] + "...")
user1 = fhqtest.admin_session.users_add(user1_data)
fhqtest.check_response(user1, "User1 succesfull created")
fhqtest.print_bold("Try create user2...")
user2 = fhqtest.admin_session.users_add(user2_data)
fhqtest.check_response(user2, "User2 succesfull created")
fhqtest.print_bold("Try create user3...")
user3 = fhqtest.admin_session.users_add(user3_data)
fhqtest.check_response(user3, "User3 succesfull created")
fhqtest.print_bold("Check unique user3 by email...")
user3_again = fhqtest.admin_session.users_add(user3_data_again)
fhqtest.alert(user3_again is None, 'Could not get response (users_add/user3 again)')
if user3_again['result'] == "DONE":
fhqtest.log_err("Wrong creating user email must be unique")
else:
fhqtest.print_success("User3 again - OK")
fhqtest.print_bold("Check unique user by uuid...")
user3_again2 = fhqtest.admin_session.users_add({"uuid": USER3_UUID, "email": "user3_test", "nick": "nick_user3_again", "password": "******", "role": "user"})
fhqtest.alert(user3_again2 is None, 'Could not get response (users_add/user3 again2)')
if user3_again2['result'] == "DONE":
fhqtest.log_err("Wrong creating user uuid must be unique")
else:
fhqtest.print_success("User3 again - OK")
fhqtest.print_bold("Find user by nick...")
users = fhqtest.admin_session.users({"onpage": 10, "page": 0, "filter_text": "nick_user2"})
# users_count = users["count"]
user_found = None
for usr in users["data"]:
if usr['email'] == "user2":
user_found = usr
fhqtest.alert(user_found is None, 'Could not find user2')
if user_found is not None:
fhqtest.print_success("User2 found success - OK")
fhqtest.print_bold("Update user country... ")
fhqtest.alert(user_found["country"] != "", 'User country must be empty ')
user2_update = fhqtest.admin_session.user_update({
"userid": user_found["id"],
"country": "Some country",
"university": "Some university",
})
fhqtest.alert(user2_update is None, 'Could not find user2')
fhqtest.check_response(user2_update, "User2 succesfull updated")
user2_update = user2_update["data"]
if "country" not in user2_update:
fhqtest.throw_err("Not found field 'country' in response after user update")
elif user2_update["country"] != "Some country":
fhqtest.throw_err("Field 'country' expected value of 'Some country'")
if "university" not in user2_update:
fhqtest.throw_err("Not found field 'university' in response after user update")
elif user2_update["university"] != "Some university":
fhqtest.throw_err("Field 'university' expected value of 'Some university'")
if "nick" not in user2_update:
fhqtest.throw_err("Not found field 'nick' in response after user update")
if "about" not in user2_update:
fhqtest.throw_err("Not found field 'about' in response after user update")
if "created" not in user2_update:
fhqtest.throw_err("Not found field 'created' in response after user update")
if "region" not in user2_update:
fhqtest.throw_err("Not found field 'region' in response after user update")
if "email" not in user2_update:
fhqtest.throw_err("Not found field 'email' in response after user update")
if "role" not in user2_update:
fhqtest.throw_err("Not found field 'role' in response after user update")
# TODO
# if "updated" not in user2_update:
# fhqtest.log_err("Not found field 'updated' in response after user update")
# exit(-1)
if "uuid" not in user2_update:
fhqtest.log_err("Not found field 'uuid' in response after user update")
exit(-1)
test_login('user1')
test_login('user2')
test_login('user3')
fhqtest.print_bold("Login by user2... ")
user2_session = FreeHackQuestClient(fhqtest.TEST_SERVER)
user2_login = user2_session.login({"email": "user2", "password": "******"})
fhqtest.alert(user2_login is None, 'Could not login as user2 (1)')
fhqtest.alert(user2_login['result'] == 'FAIL', 'Could not login as user2 (2) (fail)')
if user2_login['result'] == 'DONE':
fhqtest.print_success("User2 login success - OK")
fhqtest.print_bold("User tokens... ")
user2_tokens = user2_session.users_tokens({})
user2_session.close()
if user2_tokens['result'] != 'DONE':
fhqtest.log_err("User2 tokens failed")
exit(-1)
else:
fhqtest.print_success("User2 tokens success - OK")
# deprecated method
user2_found1 = fhqtest.admin_session.user({"userid": user_found["id"]})
fhqtest.alert(user2_found1 is None, 'Could not get user2')
fhqtest.check_response(user2_found1, "User2 succesfull got (1)")
user2_found1 = user2_found1['data']
if "email" not in user2_found1:
fhqtest.log_err("Not found field 'email' in response user2_found1")
exit(-1)
elif user2_found1['email'] != 'user2':
fhqtest.log_err("Expected field 'email' value 'user2', but got '" + user2_found1['email'] + "'")
exit(-1)
# TODO
user2_found2 = fhqtest.admin_session.users_info({"uuid": user_found["id"]})
fhqtest.alert(user2_found2 is None, 'Could not get user2')
fhqtest.check_response(user2_found2, "User2 succesfull got (2)")
if "email" not in user2_found1:
fhqtest.throw_err("Not found field 'email' in response user2_found1")
elif user2_found1['email'] != 'user2':
fhqtest.throw_err("Expected field 'email' value 'user2', but got '" + user2_found1['email'] + "'")
sys.exit(-1)
'''curr_user = fhqtest.admin_session.users_info({})
fhqtest.alert(curr_user == None, 'Could not get user2')
fhqtest.check_response(curr_user, "User2 succesfull got (2)")
if "email" not in curr_user:
fhqtest.log_err("Not found field 'email' in response curr_user")
exit(-1)
elif curr_user['email'] != 'user2':
fhqtest.log_err("Expected field 'email' value 'user2', but got '" + curr_user['email'] + "'")
exit(-1)'''
user2_skills = fhqtest.admin_session.user_skills({"userid": user_found["id"]})
fhqtest.alert(user2_skills is None, 'Could not get user skills')
fhqtest.check_response(user2_skills, "User2 succesfull got skills")
pprint(user2_skills)
user3_remove = fhqtest.admin_session.users_delete({
"userid": user3['data']['userid'], "password": fhqtest.ADMIN_PASSWORD
})
fhqtest.alert(user3_remove is None, 'Could not remove user')
fhqtest.check_response(user3_remove, "User3 succesfull removed")
user2_remove = fhqtest.admin_session.users_delete({
"userid": user_found["id"], "password": fhqtest.ADMIN_PASSWORD
})
fhqtest.alert(user2_remove is None, 'Could not remove user')
fhqtest.check_response(user2_remove, "User2 succesfull removed")
def run_tests():
# Cleanup
fhqtest.print_bold("Clean up test data... ")
game2 = fhqtest.admin_session.game_info({"uuid": fhqtest.GAME_UUID2})
fhqtest.alert(game2 == None, 'Could not get response')
if game2['result'] == "DONE":
game2_delete_r = fhqtest.admin_session.game_delete({
"uuid":
fhqtest.GAME_UUID2,
"admin_password":
fhqtest.ADMIN_PASSWORD
})
fhqtest.alert(game2_delete_r == None,
'Could not get response (game_delete)')
if game2_delete_r['result'] == 'FAIL':
fhqtest.log_err("Could not delete prevously game: " +
str(game2_delete_r))
raise ValueError('Could not delete prevously game')
fhqtest.print_success("Cleaned")
game_name = fhqtest.generate_random(255)
game_description = fhqtest.generate_random(300)
game_teams = fhqtest.generate_random(255)
game_state = "original"
game_form = "online"
game_type = "jeopardy"
game_date_start = "2000-01-01 00:00:00"
game_date_stop = "2001-01-01 00:00:00"
game_date_restart = "2011-01-01 00:00:00"
# test create game
fhqtest.print_bold("Try create game...")
game2 = fhqtest.admin_session.game_create({
"uuid": fhqtest.GAME_UUID2,
"name": game_name,
"description": game_description,
"state": game_state,
"form": game_form,
"type": game_type,
"date_start": game_date_start,
"date_stop": game_date_stop,
"date_restart": game_date_restart,
"organizators": game_teams
})
fhqtest.alert(game2 == None, 'Could not get response (2)')
fhqtest.check_response(game2, "Game succesfull created")
if game2['result'] == 'FAIL':
raise ValueError('Could not create game')
# test find game
fhqtest.print_bold("Find game by uuid... ")
game2 = fhqtest.admin_session.game_info({"uuid": fhqtest.GAME_UUID2})
fhqtest.alert(game2 == None, 'Could not get response')
fhqtest.check_response(game2, "Game found")
game2 = game2['data']
fhqtest.check_values("name of game", game2['name'], game_name)
fhqtest.check_values("organizators of game", game2['organizators'],
game_teams)
fhqtest.check_values("form of game", game2['form'], game_form)
fhqtest.check_values("state of game", game2['state'], game_state)
fhqtest.check_values("type of game", game2['type'], game_type)
fhqtest.check_values("description of game", game2['description'],
game_description)
fhqtest.check_values("maxscore of game", game2['maxscore'], 0)
gameid = game2['local_id']
# print("gameid: " + str(gameid))
# list of games
fhqtest.print_bold("Get list of games... ")
games_list = fhqtest.admin_session.games({})
fhqtest.alert(game2 == None, 'Could not get response')
fhqtest.check_response(games_list, "Games list got")
bFound = False
for game_ in games_list['data']:
if game_['uuid'] == fhqtest.GAME_UUID2:
bFound = True
if bFound != True:
fhqtest.log_err("Game not found in list")
else:
fhqtest.print_success("Game found in list")
'''
Update game name
'''
game_name = fhqtest.generate_random(255)
fhqtest.print_bold("Update game... ")
game_updt = fhqtest.admin_session.game_update({
"uuid": fhqtest.GAME_UUID2,
"name": game_name,
})
fhqtest.alert(game_updt == None, 'Could not get response')
if game_updt['result'] == 'FAIL':
fhqtest.log_err(game_updt['error'])
else:
game2_new = fhqtest.admin_session.game_info(
{"uuid": fhqtest.GAME_UUID2})
fhqtest.print_bold("Check name after update... ")
fhqtest.check_response(game2_new, "Games list got")
game2_new = game2_new['data']
fhqtest.print_bold("Check the game updated name... ")
if game2_new['name'] != game_name:
fhqtest.log_err("Game updated has wrong name expected '" +
game_name + "' got '" + game2_new['name'] + "'")
else:
fhqtest.print_success("Game the game updated name ok")
fhqtest.print_bold("Check the game updated organizators... ")
if game2_new['organizators'] != game_teams:
fhqtest.log_err("Game updated has wrong organizators expected '" +
game_teams + "' got '" +
game2_new['organizators'] + "'")
else:
fhqtest.print_success("Game the game updated organizators ok")
fhqtest.print_bold("Check the game updated description... ")
if game2_new['description'] != game_description:
fhqtest.log_err("Game updated has wrong description expected '" +
game_description + "' got '" +
game2_new['description'] + "'")
else:
fhqtest.print_success("Game the game updated description ok")
fhqtest.print_bold("Check the game updated maxscore... ")
if game2_new['maxscore'] != 0:
fhqtest.log_err(
"Game updated has wrong maxscore expected '0' got '" +
str(game2_new['maxscore']) + "'")
else:
fhqtest.print_success("Game the game updated maxscore ok")
# TODO upload log for test game
fhqtest.print_bold("Game update logo test... ")
f = open("files/game1.png", 'rb')
image_png_base64 = f.read()
f.close()
img_len = len(image_png_base64)
if img_len != 17045:
fhqtest.log_err("Game Logo wrong size, current " + str(img_len) +
", but expected 17045")
image_png_base64 = base64.b64encode(image_png_base64)
image_png_base64 = image_png_base64.decode("utf-8")
game_img = fhqtest.admin_session.game_update_logo({
"uuid":
fhqtest.GAME_UUID2,
"image_png_base64":
image_png_base64
})
fhqtest.alert(game_img == None, 'Could not get response')
fhqtest.check_response(game_img, "Game Logo updated")
# cleanup export files
fhqtest.print_bold("Game cleanup export test... ")
tmp_dir_unpack_zip = fhqtest.TMP_DIR + '/game2'
game_zip_path = fhqtest.TMP_DIR + '/game_' + fhqtest.GAME_UUID2 + '.zip'
if os.path.isdir(tmp_dir_unpack_zip):
shutil.rmtree(tmp_dir_unpack_zip)
if os.path.exists(game_zip_path):
os.remove(game_zip_path)
# export
fhqtest.print_bold("Game export test... ")
game_exp = fhqtest.admin_session.game_export({"uuid": fhqtest.GAME_UUID2})
fhqtest.alert(game_exp == None, 'Could not get response')
fhqtest.check_response(game_exp, "Game exported")
if 'game_' + fhqtest.GAME_UUID2 + '.zip' != game_exp['data'][
'zipfile_name']:
fhqtest.log_err("zipfile_name for game is wrong ")
game_zip = base64.b64decode(game_exp['data']['zipfile_base64'])
f = open(game_zip_path, 'wb')
f.write(game_zip)
f.close()
zip_ref = zipfile.ZipFile(game_zip_path, 'r')
zip_ref.extractall(tmp_dir_unpack_zip)
zip_ref.close()
img_exported_path = tmp_dir_unpack_zip + '/' + fhqtest.GAME_UUID2 + '.png'
json_exported_path = tmp_dir_unpack_zip + '/' + fhqtest.GAME_UUID2 + '.json'
if not os.path.exists(img_exported_path):
fhqtest.log_err("Not found image in zip " + img_exported_path)
if not os.path.exists(json_exported_path):
fhqtest.log_err("Not found json in zip " + json_exported_path)
else:
with open(json_exported_path) as f:
game2_exported = json.load(f)
# pprint(game2_exported)
fhqtest.print_bold("Check the export game name... ")
if game2_exported['name'] != game_name:
fhqtest.log_err("Exported game has wrong name expected '" +
game_name + "' got '" + game2_exported['name'] +
"'")
else:
fhqtest.print_success("Exported game name ok")
fhqtest.print_bold("Check the export game organizators... ")
if game2_exported['organizators'] != game_teams:
fhqtest.log_err("Exported game has wrong organizators expected '" +
game_teams + "' got '" +
game2_exported['organizators'] + "'")
else:
fhqtest.print_success("Exported game organizators ok")
fhqtest.print_bold("Check the export game description... ")
if game2_exported['description'] != game_description:
fhqtest.log_err("Exported game has wrong description expected '" +
game_description + "' got '" +
game2_exported['description'] + "'")
else:
fhqtest.print_success("Exported game description ok")
fhqtest.print_bold("Check the export game maxscore... ")
if game2_exported['maxscore'] != 0:
fhqtest.log_err(
"Exported game has wrong maxscore expected '0' got '" +
str(game2_exported['maxscore']) + "'")
else:
fhqtest.print_success("Exported game maxscore ok")
gameid = game2_exported['local_id']
# print(game_exp)
# remove game
fhqtest.print_bold("Remove game by uuid... ")
resp = fhqtest.admin_session.game_delete({
"uuid":
fhqtest.GAME_UUID2,
"admin_password":
fhqtest.ADMIN_PASSWORD
})
fhqtest.check_response(resp, "Game removed")
fhqtest.check_response(resp, "TODO Game import")
'''
def run_tests():
# Cleanup
fhqtest.clean_all_quests()
gameid = fhqtest.find_first_gameid()
# TODO symlinks to quests_create
quest_name = fhqtest.generate_random(255).strip()
quest_text = fhqtest.generate_random(300).strip()
quest_answer = fhqtest.generate_random(255).strip()
quest_answer_format = fhqtest.generate_random(255).strip()
quest_author = fhqtest.generate_random(50).strip()
quest_state = "open"
quest_subject = "trivia"
quest_score = 555
quest_description_state = fhqtest.generate_random(255).strip()
quest_copyright = fhqtest.generate_random(100).strip()
fhqtest.print_bold("Try create quest...")
quest1 = fhqtest.admin_session.createquest({
"uuid": fhqtest.QUEST_UUID1,
"gameid": gameid,
"name": quest_name,
"text": quest_text,
"score": quest_score,
"author": quest_author,
"subject": quest_subject,
"answer": quest_answer,
"answer_format": quest_answer_format,
"state": quest_state,
"description_state": quest_description_state,
"copyright": quest_copyright,
})
fhqtest.alert(quest1 == None, 'Could not get response (2)')
fhqtest.check_response(quest1, "Quest succesfull created")
questid1 = quest1['questid']
quest1_new = fhqtest.admin_session.quest({"questid": questid1})
quest1_new_hints = quest1_new['hints']
quest1_new_files = quest1_new['files']
quest1_new_game = quest1_new['game']
quest1_new = quest1_new['quest']
pprint(quest1_new)
fhqtest.check_values("name of quest", quest1_new['name'], quest_name)
fhqtest.check_values("author of quest", quest1_new['author'], quest_author)
fhqtest.check_values("answer of quest", quest1_new['answer'], quest_answer)
fhqtest.check_values("answer format of quest", quest1_new['answer_format'], quest_answer_format)
fhqtest.check_values("description_state of quest", quest1_new['description_state'], quest_description_state)
fhqtest.check_values("score of quest", quest1_new['score'], quest_score)
fhqtest.check_values("state of quest", quest1_new['state'], quest_state)
fhqtest.check_values("subject of quest", quest1_new['subject'], quest_subject)
fhqtest.check_values("text of quest", quest1_new['text'], quest_text)
fhqtest.check_values("copyright of quest", quest1_new['copyright'], quest_copyright)
quest1_hint1 = fhqtest.generate_random(255).strip()
quest1_hint2 = fhqtest.generate_random(255).strip()
quest1_hint3 = fhqtest.generate_random(255).strip()
fhqtest.print_bold("Add hint to quest...")
h1 = fhqtest.admin_session.addhint({"questid": questid1, "hint": quest1_hint1})
fhqtest.alert(h1 == None, 'Could not get response (hint1)')
fhqtest.check_response(h1, "Quest hint succesfull created")
pprint(h1)
h2 = fhqtest.admin_session.addhint({"questid": questid1, "hint": quest1_hint2})
fhqtest.alert(h2 == None, 'Could not get response (hint2)')
fhqtest.check_response(h2, "Quest hint succesfull created")
pprint(h2)
h3 = fhqtest.admin_session.addhint({"questid": questid1, "hint": quest1_hint3})
fhqtest.alert(h3 == None, 'Could not get response (hint3)')
fhqtest.check_response(h3, "Quest hint succesfull created")
pprint(h3) # TODO return id and text
fhqtest.print_bold("Try update quest...")
quest_name2 = fhqtest.generate_random(255).strip()
quest_text2 = fhqtest.generate_random(300).strip()
quest_answer2 = fhqtest.generate_random(255).strip()
quest_answer_format2 = fhqtest.generate_random(255).strip()
quest_author2 = fhqtest.generate_random(50).strip()
quest_state2 = "broken"
quest_subject2 = "stego"
quest_score2 = 456
quest_description_state2 = fhqtest.generate_random(255).strip()
quest_copyright2 = fhqtest.generate_random(100).strip()
quest1_update = fhqtest.admin_session.quest_update({
"questid": questid1,
"name": quest_name2,
"gameid": gameid,
"text": quest_text2,
"score": quest_score2,
"author": quest_author2,
"subject": quest_subject2,
"answer": quest_answer2,
"answer_format": quest_answer_format2,
"state": quest_state2,
"description_state": quest_description_state2,
"copyright": quest_copyright2,
})
fhqtest.alert(quest1_update == None, 'Could not get response (4)')
fhqtest.check_response(quest1_update, "Quest succesfull update")
quest1_updated = fhqtest.admin_session.quest({"questid": questid1})
quest1_updated_hints = quest1_updated['hints']
quest1_updated_files = quest1_updated['files']
quest1_updated_game = quest1_updated['game']
quest1_updated = quest1_updated['quest']
print("quest1_updated = " + str(quest1_updated))
fhqtest.check_values("name of quest", quest1_updated['name'], quest_name2)
fhqtest.check_values("author of quest", quest1_updated['author'], quest_author2)
fhqtest.check_values("answer of quest", quest1_updated['answer'], quest_answer2)
fhqtest.check_values("answer format of quest", quest1_updated['answer_format'], quest_answer_format2)
fhqtest.check_values("description_state of quest", quest1_updated['description_state'], quest_description_state2)
fhqtest.check_values("score of quest", quest1_updated['score'], quest_score2)
fhqtest.check_values("state of quest", quest1_updated['state'], quest_state2)
fhqtest.check_values("subject of quest", quest1_updated['subject'], quest_subject2)
fhqtest.check_values("text of quest", quest1_updated['text'], quest_text2)
fhqtest.check_values("copyright of quest", quest1_updated['copyright'], quest_copyright2)
fhqtest.check_values("hint1 of quest", quest1_updated_hints[0]['text'], quest1_hint1)
fhqtest.check_values("hint2 of quest", quest1_updated_hints[1]['text'], quest1_hint2)
fhqtest.check_values("hint3 of quest", quest1_updated_hints[2]['text'], quest1_hint3)
# try remove hint
h2_remove = fhqtest.admin_session.deletehint({"hintid": quest1_updated_hints[1]['id']})
fhqtest.alert(h2_remove == None, 'Could not get response (hint2_remove)')
fhqtest.check_response(h2_remove, "Quest hint2 succesfull removed")
fhqtest.print_bold("Try upload file to quest...")
# pprint(quest1_updated)
quest_uuid = quest1_updated['uuid']
resp = fhqtest.admin_session.quests_files_upload({
"quest_uuid": quest_uuid,
"file_base64": "SGVsbG8gd29ybGQh",
"file_name": "test1.txt",
})
fhqtest.alert(resp['result'] == 'FAIL', 'Wrong response')
fhqtest.check_response(resp, "Quest quests_files_upload succesfull")
questid = quest1_updated['id']
resp = fhqtest.admin_session.quests({"gameid": gameid})
fhqtest.alert(resp == None, 'Could not get response (quests)')
fhqtest.check_response(resp, "quest get filtered")
fhqtest.alert(resp['result'] == 'FAIL', 'Wrong response')
fhqtest.alert(resp['data'][0]['questid'] != questid, 'Wrong work filter by gameid in request quests')
#
fhqtest.print_bold("Try answerlist...")
r_answerlist = fhqtest.admin_session.answerlist({"page": 0, "onpage": 10})
fhqtest.alert(r_answerlist == None, 'Could not get response (r_answerlist)')
fhqtest.check_response(r_answerlist, "Answer list succesfull got")
pprint(r_answerlist)
# TODO check this
# Cleanup
fhqtest.clean_all_quests()
def run_tests():
fhqtest.clean_all_classbooks()
records = []
for _ in range(10):
records.append({
'name': fhqtest.generate_random(10),
'content': fhqtest.generate_random(255),
'uuid': fhqtest.generate_random_uuid(),
})
fhqtest.print_bold("Create new records")
parentids = []
parentids.append(0) # root
for rec in records:
rec['parentid'] = random.choice(parentids)
r = fhqtest.admin_session.classbook_add_record({
"parentid": rec['parentid'],
"name": rec['name'],
"content": rec['content'],
"uuid": rec['uuid'],
"ordered": 0
})
fhqtest.check_response(r, "Record " + rec['uuid'] + " succesfull in parent " + str(rec['parentid']) + " created")
if r['result'] == 'FAIL':
raise ValueError('Could not create new classbook')
rec['classbookid'] = r['data']['classbookid']
parentids.append(rec['classbookid'])
# pprint(records)
# Cleanup
''' user1 = None
user2 = None
user3 = None
fhqtest.print_bold("Clean up test data... ")
users = fhqtest.admin_session.users({"onpage": 10, "page": 0, "filter_text": "user1"})
users_count = users["count"]
for usr in users["data"]:
if usr['email'] == "user1":
user1 = usr
if usr['created'] == '':
fhqtest.log_err("Field created could not be empty for user #" + str(usr['id']))
exit(-1)
users = fhqtest.admin_session.users({"onpage": 10, "page": 0, "filter_text": "user2"})
users_count = users["count"]
for usr in users["data"]:
if usr['email'] == "user2":
user2 = usr
if usr['created'] == '':
fhqtest.log_err("Field created could not be empty for user #" + str(usr['id']))
exit(-1)
users = fhqtest.admin_session.users({"onpage": 10, "page": 0, "filter_text": "user3"})
users_count = users["count"]
for usr in users["data"]:
if usr['email'] == "user3":
user3 = usr
if usr['created'] == '':
fhqtest.log_err("Field created could not be empty for user #" + str(usr['id']))
exit(-1)
users = fhqtest.admin_session.users({"onpage": 10, "page": 0, "filter_text": "user3_test"})
users_count = users["count"]
for usr in users["data"]:
if usr['email'] == "user3_test":
user3_test = usr
if usr['created'] == '':
fhqtest.log_err("Field created could not be empty for user #" + str(usr['id']))
exit(-1)
if user1 != None:
user1_delete = fhqtest.admin_session.user_delete({
"userid": user1['id'],
"password": fhqtest.ADMIN_PASSWORD
})
fhqtest.check_response(user1_delete, "User1 succesfull removed")
user1 = None
if user2 != None:
fhqtest.admin_session.user_delete({"userid": user2['id'], "password": fhqtest.ADMIN_PASSWORD})
user2 = None
if user3 != None:
fhqtest.admin_session.user_delete({"userid": user3['id'], "password": fhqtest.ADMIN_PASSWORD})
user3 = None
if user3_test != None:
fhqtest.admin_session.user_delete({"userid": user3_test['id'], "password": fhqtest.ADMIN_PASSWORD})
user3_test = None
fhqtest.print_success("Cleaned")
# test create users
fhqtest.print_bold("Try create user1...")
user1 = fhqtest.admin_session.users_add({
"uuid": fhqtest.USER1_UUID,
"email": "user1",
"nick": "nick_user1",
"password": "******",
"role": "user"
})
fhqtest.alert(user1 == None, 'Could not get response (users_add/user1)')
fhqtest.check_response(user1, "User1 succesfull created")
fhqtest.print_bold("Try create user2...")
user2 = fhqtest.admin_session.users_add({
"uuid": fhqtest.USER2_UUID,
"email": "user2",
"nick": "nick_user2",
"password": "******",
"role": "user"
})
fhqtest.alert(user2 == None, 'Could not get response (users_add/user2)')
fhqtest.check_response(user1, "User2 succesfull created")
fhqtest.print_bold("Try create user3...")
user3 = fhqtest.admin_session.users_add({
"uuid": fhqtest.USER3_UUID,
"email": "user3",
"nick": "nick_user3",
"password": "******",
"role": "user"
})
fhqtest.alert(user3 == None, 'Could not get response (users_add/user3)');
fhqtest.check_response(user1, "User3 succesfull created")
fhqtest.print_bold("Check unique user3 by email...")
user3_again = fhqtest.admin_session.users_add({
"uuid": fhqtest.USER3_UUID,
"email": "user3",
"nick": "nick_user3_again",
"password": "******",
"role": "user"
})
fhqtest.alert(user3_again == None, 'Could not get response (users_add/user3 again)')
if user3_again['result'] == "DONE":
fhqtest.log_err("Wrong creating user email must be unique")
else:
fhqtest.print_success("User3 again - OK")
fhqtest.print_bold("Check unique user by uuid...")
user3_again2 = fhqtest.admin_session.users_add({"uuid": fhqtest.USER3_UUID, "email": "user3_test", "nick": "nick_user3_again", "password": "******", "role": "user"})
fhqtest.alert(user3_again2 == None, 'Could not get response (users_add/user3 again2)')
if user3_again2['result'] == "DONE":
fhqtest.log_err("Wrong creating user uuid must be unique")
else:
fhqtest.print_success("User3 again - OK")
fhqtest.print_bold("Find user by nick...")
users = fhqtest.admin_session.users({"onpage": 10, "page": 0, "filter_text": "nick_user2"})
users_count = users["count"]
user_found = None
for usr in users["data"]:
if usr['email'] == "user2":
user_found = usr
fhqtest.alert(user_found == None, 'Could not find user2')
if user_found != None:
fhqtest.print_success("User2 found success - OK")
fhqtest.print_bold("Update user country... ")
fhqtest.alert(user_found["country"] != "", 'User country must be empty ')
user2_update = fhqtest.admin_session.user_update({
"userid": user_found["id"],
"country": "Some country",
"university": "Some university",
})
fhqtest.alert(user2_update == None, 'Could not find user2')
fhqtest.check_response(user2_update, "User2 succesfull updated")
user2_update = user2_update["data"]
if "country" not in user2_update:
fhqtest.log_err("Not found field 'country' in response after user update")
exit(-1)
elif user2_update["country"] != "Some country":
fhqtest.log_err("Field 'country' expected value of 'Some country'")
exit(-1)
if "university" not in user2_update:
fhqtest.log_err("Not found field 'university' in response after user update")
exit(-1)
elif user2_update["university"] != "Some university":
fhqtest.log_err("Field 'university' expected value of 'Some university'")
exit(-1)
if "nick" not in user2_update:
fhqtest.log_err("Not found field 'nick' in response after user update")
exit(-1)
if "about" not in user2_update:
fhqtest.log_err("Not found field 'about' in response after user update")
exit(-1)
if "created" not in user2_update:
fhqtest.log_err("Not found field 'created' in response after user update")
exit(-1)
if "region" not in user2_update:
fhqtest.log_err("Not found field 'region' in response after user update")
exit(-1)
if "email" not in user2_update:
fhqtest.log_err("Not found field 'email' in response after user update")
exit(-1)
if "role" not in user2_update:
fhqtest.log_err("Not found field 'role' in response after user update")
exit(-1)
# TODO
# if "updated" not in user2_update:
# fhqtest.log_err("Not found field 'updated' in response after user update")
# exit(-1)
if "uuid" not in user2_update:
fhqtest.log_err("Not found field 'uuid' in response after user update")
exit(-1)
fhqtest.print_bold("Login by user2... ")
user2_session = FreeHackQuestClient(fhqtest.TEST_SERVER)
user2_login = user2_session.login({"email": "user2", "password": "******"})
fhqtest.alert(user2_login == None, 'Could not login as user2')
fhqtest.alert(user2_login['result'] == 'FAIL', 'Could not login as user2 (fail)')
if user2_login['result'] == 'DONE':
fhqtest.print_success("User2 login success - OK")
user2_session.close()
user2_session = None
# deprecated method
user2_found1 = fhqtest.admin_session.user({"userid": user_found["id"]})
fhqtest.alert(user2_found1 == None, 'Could not get user2')
fhqtest.check_response(user2_found1, "User2 succesfull got (1)")
user2_found1 = user2_found1['data']
if "email" not in user2_found1:
fhqtest.log_err("Not found field 'email' in response user2_found1")
exit(-1)
elif user2_found1['email'] != 'user2':
fhqtest.log_err("Expected field 'email' value 'user2', but got '" + user2_found1['email'] + "'")
exit(-1)
# TODO
user2_found2 = fhqtest.admin_session.users_info({"uuid": user_found["id"]})
fhqtest.alert(user2_found2 == None, 'Could not get user2')
fhqtest.check_response(user2_found2, "User2 succesfull got (2)")
if "email" not in user2_found1:
fhqtest.log_err("Not found field 'email' in response user2_found1")
exit(-1)
elif user2_found1['email'] != 'user2':
fhqtest.log_err("Expected field 'email' value 'user2', but got '" + user2_found1['email'] + "'")
exit(-1)
'''
fhqtest.clean_all_classbooks()
