def test_standup_start(): #standup_start(token, channel_id), returns time_finish #SETUP TESTS BEGIN #create new users: authRegDict = auth_register("*****@*****.**", "password", "Ben", "Kah") token = authRegDict["token"] authRegDict2 = auth_register("*****@*****.**", "password", "Jeffrey", "Oh") token2 = authRegDict2["token"] #create channel chanCreateDict = channels_create(token, "test channel", True) chanId = chanCreateDict["channel_id"] channel_join(token, chanId) #SETUP TESTS END # low = datetime.now() + timedelta(seconds=4) # up = datetime.now() + timedelta(seconds=6) low_bound = time() + float(4.8) up_bound = time() + float(5.2) finish = standup_start(token, chanId, 5) standup_finish = finish["time_finish"] # low_bound = low.replace(tzinfo=timezone.utc).timestamp() # up_bound = up.replace(tzinfo=timezone.utc).timestamp() assert low_bound < standup_finish assert up_bound > standup_finish with pytest.raises(ValueError): assert standup_start(token, 5555, 5) # channel_id is not a valid channel with pytest.raises(ValueError): assert standup_start(token2, chanId, 5) # token is invalid
def test_search_valid(): ch_id = channels_create(hamish['token'], 'comp', True) # Send a message new_message_id = message_send(hamish['token'], ch_id['channel_id'], 'yes') # Save the time created message_store = get_messages_store() for id in message_store['Messages']: if id['message_id'] == new_message_id['message_id']: time_created = id['time_created'] reacts = id['reacts'] pin_status = id['is_pinned'] assert(search(hamish['token'], 'yes') == { 'messages': [ { 'message_id': new_message_id['message_id'], 'u_id': hamish['u_id'], 'message': 'yes', 'time_created': str(time_created), 'reacts': reacts, 'is_pinned': pin_status, } ] } ) # Valid Display
def test_channels_create_valid(): channel_id = channels_create(hamish_token['token'], 'New_channel', True) # Now to call our storage and assert that the channel_id is present in our store channel_store = get_channel_store() result = False for probe in channel_store['Channels']: if probe['channel_id'] == channel_id['channel_id']: result = True # Now we assert the value of result assert (result == True)
def c_create(): data = request.get_json() token = data['token'] name = data['name'] is_public = bool(data['is_public']) channel_id = channels_create(token, name, is_public) print(get_channel_store()) #message_id = {'message_id':1} return dumps(channel_id)
def test_admin_userpermission_change(): #admin_userpermission_change(token, u_id, permission_id), no return value #SETUP TESTS BEGIN #create new admin: authRegDict = auth_login("*****@*****.**", "password") token = authRegDict["token"] userId = authRegDict["u_id"] #create regular user: authRegDict2 = auth_register("*****@*****.**", "password", "Jeffrey", "Oh") token2 = authRegDict2["token"] userId2 = authRegDict2["u_id"] #create channel from admin: chanCreateDict = channels_create(token, "test channel", True) chanId = chanCreateDict["channel_id"] channel_join(token, chanId) #add regular user to first channel: channel_invite(token, chanId, userId2) #SETUP TESTS END with pytest.raises(ValueError): assert admin_userpermission_change(token, userId, 0) #invalid permission_id with pytest.raises(ValueError): assert admin_userpermission_change(token, userId, 4) with pytest.raises(AccessError): assert admin_userpermission_change(token, 55555, 3) #invalid user ID user2 = user_from_token(token2) # check user2 is a member (not an owner or admin) assert check_slackr_owner(user2) == False assert check_slackr_admin(user2) == False # check user2 is an owner admin_userpermission_change(token, userId2, 1) assert check_slackr_owner(user2) == True assert check_slackr_admin(user2) == False # check user2 is an admin admin_userpermission_change(token, userId2, 2) assert check_slackr_owner(user2) == False assert check_slackr_admin(user2) == True # change user2 back to member admin_userpermission_change(token, userId2, 3) # check user2 cannot change permission of user1 with pytest.raises(AccessError): admin_userpermission_change(token2, userId, 3) user = user_from_token(token) # check slackr owner can be made admin admin_userpermission_change(token, userId, 2) assert check_slackr_admin(user)
def test_standup_send(): #standup_send(token, channel_id, message), no return value #SETUP TESTS BEGIN #create new users: authRegDict = auth_register("*****@*****.**", "password", "Ben", "Kah") token = authRegDict["token"] authRegDict2 = auth_register("*****@*****.**", "password", "Jeffrey", "Oh") token2 = authRegDict2["token"] #create channels: chanCreateDict = channels_create(token, "test channel", True) chanId = chanCreateDict["channel_id"] channel_join(token, chanId) chanCreateDict2 = channels_create(token, "test channel 2", True) chanId2 = chanCreateDict2["channel_id"] channel_join(token, chanId2) #SETUP TESTS END with pytest.raises(ValueError): assert standup_send(token, chanId, "this is sent before standup_start is called") #create time_finish finish = standup_start(token, chanId, 5) standup_finish = finish["time_finish"] standup_send(token, chanId, "Standup message") with pytest.raises(AccessError): assert standup_send( token2, chanId, "Standup message with user not a member of the channel") strOver1000 = "yeah bo" + "i" * 1000 with pytest.raises(ValueError): assert standup_send(token, chanId, strOver1000) with pytest.raises(ValueError): assert standup_send(token, chanId2, "Standup message with wrong chanId")
def c_create(): """ This is a flask wrapper for the channels_create function Parameters: No parameters Returns: (dictionary): A dictionary with the channel_id of the new channel """ data = request.get_json() token = data['token'] name = data['name'] is_public = bool(data['is_public']) channel_id = channels_create(token, name, is_public) return dumps(channel_id)
def test_search(): #search(token, query_str), returns messages #SETUP TESTS BEGIN #create new users: authRegDict = auth_register("*****@*****.**", "password", "Ben", "Kah") token = authRegDict["token"] #create channel chanCreateDict = channels_create(token, "test channel", True) chanId = chanCreateDict["channel_id"] channel_join(token, chanId) #create messages msg_send(token, "New message sent", chanId) msg_send(token, "Another message", chanId) msg_send(token, "A completely different string", chanId) #SETUP TESTS END searchResultsList = search(token, "message") #first search query searchResultsList2 = search(token, "nothing to find") #second search query assert searchResultsList["messages"][1][ "message"] == "New message sent" #search results should contain these strings assert searchResultsList["messages"][0]["message"] == "Another message" assert len(searchResultsList["messages"]) == 2 assert len(searchResultsList2["messages"]) == 0 #list should be empty
def route_channels_create(): token = request.form.get('token') name = request.form.get('name') is_public = request.form.get('is_public') return dumps(channels_create(token, name, is_public))
def test_channels_create_invalid(): with pytest.raises(InputError): channels_create(hamish['token'], 'BenBenBenBenBenBenBenBenBenBenBenBenBenBen', True)
channel_id = channels_create(hamish_token['token'], 'New_channel', True) # Now to call our storage and assert that the channel_id is present in our store channel_store = get_channel_store() result = False for probe in channel_store['Channels']: if probe['channel_id'] == channel_id['channel_id']: result = True # Now we assert the value of result assert (result == True) for probe in channel_store['Channels']: if probe['channel_id'] == channel_id['channel_id']: channel_store['Channels'].remove(probe) # Lets go to our next tests channel_id_hamish = channels_create(hamish_token['token'], 'Hamish_channel', True) # Zachs channel will be private channel_id_zach = channels_create(zach_token['token'], 'Zach_channel', False) channel_id_kelly = channels_create(kelly_token['token'], 'Kelly_channel', True) # As of now, each uer is a owner and a member of their channel # Test invalid channel def test_channel_details_invalid(): with pytest.raises(AccessError): channel_details(zach['token'], channel_id_hamish['channel_id']) with pytest.raises(InputError): channel_details(zach['token'], 12345)
from error import InputError from server import defaultHandler from channel import channel_messages, channels_create from db import get_messages_store, get_user_store, get_channel_store, token_check, channel_check, message_check, react_check, get_standup_queue from message import message_edit, message_remove from message import message_send, message_send_later, message_react, message_unreact, message_pin, message_unpin from standup import standup_start, standup_active, standup_send from other import search from auth import auth_register from other import users_all from auth import auth_register import datetime from datetime import timezone hayden_dict = auth_register('*****@*****.**', 'password', 'hayden', 'smith') chan_id = channels_create(hayden_dict['token'], 'Hayden', True) print(hayden_dict) print() print(chan_id) APP = Flask(__name__) CORS(APP) APP.config['TRAP_HTTP_EXCEPTIONS'] = True APP.register_error_handler(Exception, defaultHandler) @APP.route("/standup/start", methods=['POST']) def standup_start_flask(): data = request.get_json() token = data['token']
def create_channel(): token = request.form.get('token') name = request.form.get('name') is_public = request.form.get('is_public') dic = channel.channels_create(token, name, is_public) return dumps(dic)
from server import defaultHandler from channel import channel_messages, channel_invite, channel_details, channel_messages from channel import channel_list, channels_list_all, check_if_user_in_channel_member, check_if_channel_is_public from channel import channel_leave, channel_join, channel_addowner, channel_removeowner, check_if_user_in_channel_owner, check_if_user_in_channel_owner_uid, channels_create, channel_invite from auth import auth_register from other import search from db import login, make_user, get_channel_store, get_messages_store from db import get_user_store, add_user, login, make_user from db import token_check, channel_check, u_id_check, handle_check, email_check, email_dupe_check from message import message_send from other import users_all input_dict = auth_register('*****@*****.**', 'password', 'hayden', 'smith') rob_dict = auth_register('*****@*****.**', 'robword', 'rob', 'yalater') channel_id = channels_create(input_dict['token'], "Chan1", True) message_id = message_send(input_dict['token'], channel_id['channel_id'], "Hey") message_id1 = message_send(input_dict['token'], channel_id['channel_id'], "wassup") message_id2 = message_send(input_dict['token'], channel_id['channel_id'], "hru") message_id3 = message_send(input_dict['token'], channel_id['channel_id'], "hru") #chan_id = channels_create(input_dict['token'], 'Hayden', True) print(input_dict) print() print(rob_dict) print() print() APP = Flask(__name__) CORS(APP) APP.config['TRAP_HTTP_EXCEPTIONS'] = True
#import message #import channels #import channel import pytest from error import InputError, AccessError from auth import auth_register from channel import channels_create, channel_invite from message import message_send, message_send_later, message_react, message_unreact, message_pin, message_unpin from message import message_remove, message_edit from db import get_messages_store import datetime from datetime import timezone #Assumptions #All the inputs are valid hayden_dict = auth_register('*****@*****.**', 'password', 'hayden', 'smith') chan_id = channels_create(hayden_dict['token'], 'Hayden', True) rob_dict = auth_register("*****@*****.**", "paswword123", "Rob", "Ever") #channel_invite(hayden_dict['token'], chan_id["channel_id"], rob_dict["u_id"]) message_id = message_send(hayden_dict['token'], chan_id['channel_id'], "Haydens Message") def test_message_send(): assert get_messages_store()['Messages'][0] == { 'channel_id': chan_id["channel_id"], 'message_id': message_id['message_id'], 'user_id': hayden_dict['u_id'], 'message': 'Haydens Message', 'reacts': [], 'time_created': get_messages_store()['Messages'][0]['time_created'],
from datetime import datetime, timedelta, timezone from class_defines import User, Channel, Mesg, Reacts, data, perm_admin, perm_owner, perm_member # setup auth_register('*****@*****.**', 'password', 'kenny', 'han') auth_register('*****@*****.**', 'password', 'k', 'h') auth_register('*****@*****.**', 'password', 'h', 'k') auth_login('*****@*****.**', 'password') token1 = data['accounts'][0].token # user 2 does not belong to any channel auth_login('*****@*****.**', 'password') token2 = data['accounts'][1].token auth_login('*****@*****.**', 'password') token3 = data['accounts'][2].token # user 1 is the owner of channel1 channels_create(token1, 'channel1', True) chan_id1 = data['channels'][0].channel_id # user 3 is a member of channel1 but not owner channel_join(token3, chan_id1) # a long message long_msg = 'a' * 1000 invalid_msg = 'a' * 1001 # more than 1000 characters # setup end def test_successful_msg_send(): # a normal msg assert msg_send(token1, '1st msg', chan_id1) == {'message_id': 1} assert data['channels'][0].messages[0].message_id == 1 # a msg with 1000 characters assert msg_send(token3, long_msg, chan_id1) == {'message_id': 2}