def test_send_way_later(): user1 = auth.auth_register("*****@*****.**", "reddington", "James", "Spader") chan1 = channels.channels_create(user1['token'], "Zooper Dooper", False) time1 = time_from_now(602) time2 = time_from_now(6020) mess1 = message.message_sendlater(user1['token'], chan1['channel_id'], "ahoy", time1) mess2 = message.message_sendlater(user1['token'], chan1['channel_id'], "yoha", time2) assert mess1['message_id'] == 1 assert mess2['message_id'] == 2 other.clear()
def test_standup_send_user_not_member(): """Tests an non-member of a channel trying to participate in a standup in that channel""" clear() valid_user = auth_register("*****@*****.**", "validPassword", "Validate", "Me") new_channel = channels_create(valid_user["token"], "new_channel", False) valid_user2 = auth_register("*****@*****.**", "validPassword2", "Validate2", "Me2") standup_start(valid_user["token"], new_channel["channel_id"], 3) with pytest.raises(AccessError): standup_send(valid_user2["token"], new_channel["channel_id"], "stand the f*** up!") time.sleep(3)
def test_auth_edit(): c_owner = auth_register("*****@*****.**","1234yu!","Hailey","Jung") c_token = c_owner['token'] channel = channels_create(c_token,"test",True) cid = channel['channel_id'] writer = auth_register("hkhkhk999@gmail","1asdfu!","Eunseo","Jung") w_token = writer['token'] message = message_send(w_token,cid,"Hellooo") mid = message['message_id'] no_body = auth_register("noone@gmail","1aasdffu!","Aww","Jung") n_token = no_body['token'] with pytest.raises(AccessError): message_edit(n_token, mid, "Iamtryingtofix")
def test_standup_start_after_allowed_again(): ''' Test that after the first standup is over, another can start without errors ''' clear() user = auth_register("*****@*****.**", "password", "Firstname", "Lastname") channel = channels_create(user['token'], "Channel", True) standup_start(user['token'], channel['channel_id'], 1) time.sleep(2) standup_start(user['token'], channel['channel_id'], 1) time.sleep(2)
def test_channels_listall(): """ Testing successful uses of channels_listall without any errors """ user = auth.auth_register("*****@*****.**", "passwordabc", "first_name", "last_name") new_channel = channels.channels_create(user["token"], "my_channel", True) list_result = channels.channels_listall(user["token"])["channels"] assert list_result[0]["channel_id"] == 1 assert list_result[0]["name"] == "my_channel" user2 = auth.auth_register("*****@*****.**", "passwordxyz", "first_name", "last_name") channel.channel_join(user2["token"], new_channel["channel_id"]) channels.channels_create(user2["token"], "our_channel", True) list_result2 = channels.channels_listall(user2["token"])["channels"] assert list_result2[0]["channel_id"] == 1 assert list_result2[0]["name"] == "my_channel" assert list_result2[1]["channel_id"] == 2 assert list_result2[1]["name"] == "our_channel" other.clear()
def test_channels_listall(): _, _, _, yixuan_dict, yuhan_dict = initialise_data() # get the previous channels for yuhan yuhan_prev_channels = channels_listall(yuhan_dict['token']) # creat 2 channels including different members team_lemon = channels_create(yixuan_dict['token'], "teamLemon", False) team_lemon_id = team_lemon['channel_id'] team_pears = channels_create(yuhan_dict['token'], "teamPears", False) team_pears_id = team_pears['channel_id'] # append the new added channels to the previous channels list team_lemon_dict = {'channel_id': team_lemon_id, 'name': 'teamLemon'} team_pears_dict = {'channel_id': team_pears_id, 'name': 'teamPears'} yuhan_prev_channels['channels'].append(team_lemon_dict) yuhan_prev_channels['channels'].append(team_pears_dict) # get the current channel list yuhan_curr_channels = channels_listall(yuhan_dict['token']) # check if the list is same assert yuhan_prev_channels == yuhan_curr_channels
def test_active_standupactive_token(): ''' If standup token is invalid ''' clear() user = auth.auth_register("*****@*****.**", "password", "First", "Last") channel = channels.channels_create(user['token'], "name", True) standup.standup_start(user['token'], channel["channel_id"], 2) with pytest.raises(error.AccessError): standup.standup_active('token', channel["channel_id"]) time.sleep(3)
def test_message_react_invalid_msg_id(): clear() test_user0 = create_one_test_user() # test_user0 creates 1 public channel channel_id = channels_create(test_user0['token'], "Public Channel", True) # test_user0 sends 1 message to public channel message0 = "inital message" message_send(test_user0['token'], channel_id['channel_id'], message0) with pytest.raises(InputError): assert message_react(test_user0['token'], 2, 1)
def test_message_react(): clear() test_user0 = create_one_test_user() # test_user0 creates 1 public channel channel_id = channels_create(test_user0['token'], "Public Channel", True) # test_user0 sends 1 message to public channel message0 = "inital message" message0_id = message_send(test_user0['token'], channel_id['channel_id'], message0) message_react(test_user0['token'], message0_id['message_id'], 1) == {}
def test_channels_list(): #dictionary of token and uid when user logs in and the element removes when he logs out helper_functions.clear_data() user1_email = '*****@*****.**' user1_password = '******' user1_firstname = 'USER' user1_lastname = '1' diction = auth.auth_register(user1_email, user1_password, user1_firstname, user1_lastname) token = diction.get('token') id_dict = channels.channels_create(token, user1_firstname, True) channel_id = id_dict.get('channel_id') channels.channels_create(token, user1_firstname, True) chan = channels.channels_list(token) chan = chan.get('channels') assert channel_id != None assert chan != None assert True
def test_unreact_invalid_message_id_out_channel(): """ Test a situation where a user trying to unreact to a message but not in that channel """ clear() user_a, user_b = register_n_users(2) # user_a create a channel channels_create(user_a["token"], "public_channel_a", True)["channel_id"] # user_b create a channel and send message in his own channel public_channel_id_b = channels_create(user_b["token"], "public_channel_b", True)["channel_id"] message_id_b = message_send(user_b["token"], public_channel_id_b, "I am in channel_b")["message_id"] # user_a join the channel and react to the user_b channel_join(user_a["token"], public_channel_id_b) message_react(user_a["token"], message_id_b, 1) # user_a leave the channel channel_leave(user_a["token"], public_channel_id_b) # user_a should not be able to react the the message in the public_channel_b with pytest.raises(InputError): message_unreact(user_a["token"], message_id_b, 1)
def test_channels_create_success(): reset_data() user_info = auth_register('*****@*****.**', 'sadsad', 'name', 'lastname') assert channels_create(user_info['token'], 'a' * 20, True) == { 'channel_id': 1 } assert channels_list(user_info['token']) == { 'channels': [{ 'channel_id': 1, 'name': 'a' * 20 }] }
def test_channels_create_simple(): reset_data() user_info = auth_register('*****@*****.**', 'sadsad', 'name', 'lastname') # Creating the channel assert channels_create(user_info['token'], 'a', True) == { 'channel_id': 1, } assert channels_list(user_info['token']) == { 'channels': [{ 'channel_id': 1, 'name': 'a' }], }
def test_message_react_valid_react(make_users): # setting up users and public channel user_ab, user_cd = make_users new_public_channel = channels_create(user_ab['token'], 'test_channel_public', True) # user_cd creates a private channel new_private_channel = channels_create(user_cd['token'], 'private_channel', False) msg1 = message_send(user_ab['token'], new_public_channel['channel_id'], "Hello world!") msg2 = message_send(user_cd['token'], new_private_channel['channel_id'], "Private msg") # user_cd adds user_ab to their private channel channel_invite(user_cd['token'], new_private_channel['channel_id'], user_ab['u_id']) # user_ab now reacts to both messages (1 in public, 1 in private channel) message_react(user_ab['token'], msg1['message_id'], 1) message_react(user_ab['token'], msg2['message_id'], 1) # grab the list of messages in both channels messages_public = channel_messages(user_ab['token'], new_public_channel['channel_id'], 0)['messages'] messages_private = channel_messages(user_ab['token'], new_private_channel['channel_id'], 0)['messages'] # check the reacts are there assert messages_public[0]['reacts'] == [{ 'react_id': 1, 'u_ids': [user_ab['u_id']], 'is_this_user_reacted': True, }] assert messages_private[0]['reacts'] == [{ 'react_id': 1, 'u_ids': [user_ab['u_id']], 'is_this_user_reacted': True, }]
def test_unauthorised_message_edit(): clear() info = auth.auth_register("*****@*****.**", "ihfeh3hgi00d", "Bill", "Gates") channel_id = channels.channels_create(info['token'], 'validchannelname', True) firstmessage = message.message_send(info['token'], channel_id['channel_id'], 'hello') secondinfo = auth.auth_register("*****@*****.**", "ttteh3hgi00d", "Billy", "Gale") with pytest.raises(AccessError): assert message.message_edit(secondinfo['token'], firstmessage['message_id'], 'changing')
def test_channel_join(): reset() u_id, token = get_user("user1") channel_id = channels.channels_create(token, "Example Channel", True)['channel_id'] # Function channel_join(token, channel_id) # Returns {} # Given a channel_id of a channel that the authorised user can join, adds them to that channel # Join a channel that the user is not already a member of # Create new user new_id, new_token = get_user("user2") assert channel.channel_join(new_token, channel_id) == {}
def test_message_send2(): clear() info = auth.auth_register("*****@*****.**", "ihfeh3hgi00d", "Bill", "Gates") channel_id = channels.channels_create(info['token'], 'validchannelname', True) i = 0 while i < 51: message.message_send(info['token'], channel_id['channel_id'], 'hello') i += 1 print(channel.channel_messages(info['token'], channel_id['channel_id'], 0)) assert len(channel.channel_messages(info['token'], channel_id['channel_id'], 0)['messages']) \ == 50
def test_remove_continuous_send(): clear() user = register_n_users(1) channel_id = channels_create(user["token"], "channela", is_public=True)["channel_id"] for i in range(1, 50): message = message_send(user["token"], channel_id, "message " + str(i)) message_remove(user["token"], message["message_id"]) assert channel_messages(user["token"], channel_id, 0)["end"] == -1 assert bool(channel_messages(user["token"], channel_id, 0)["messages"]) == False
def test_standupsend_tokenwrong(): ''' Invalid token ''' clear() user = auth.auth_register("*****@*****.**", "password", "First", "Last") channel = channels.channels_create(user['token'], "name", True) standup.standup_start(user['token'], channel["channel_id"], 1) with pytest.raises(error.AccessError): standup.standup_send('invalid', channel['channel_id'], 'RM') time.sleep(2)
def test_edit_invalid_user_token(): clear() user = register_n_users(1) # Create a new channel channel = channels_create(user["token"], "channel01", is_public=True) # User sends a message message = message_send(user["token"], channel["channel_id"], "test message") # Non-existent user tries to edit the message with pytest.raises(AccessError): assert message_edit(INVALID_USER_TOKEN, message["message_id"], "edited message")
def test_messageunreact_invalid_input(): ''' Testing if errors returned when given invalid input ''' clear() # Registering users, creating channels and sending messages to both user1 = auth_register("*****@*****.**", "user1pass", "user1", "last1", None) user2 = auth_register("*****@*****.**", "user2pass", "user2", "last2", None) token1 = user1['token'] token2 = user2['token'] ch_id1 = channels_create(token1, "aGreatChannel", True)['channel_id'] ch_id2 = channels_create(token2, "ChannelTwo", True)['channel_id'] m_id1 = message_send(token1, ch_id1, 'hey')['message_id'] m_id2 = message_send(token2, ch_id2, 'hello')['message_id'] message_react(token1, m_id1, 1) # Trying to remove react from a non_existing message with pytest.raises(InputError): message_unreact(token1, m_id1 + 100, 1) # Trying to unreact from a non_existing react type with pytest.raises(InputError): message_unreact(token1, m_id1, 1000) # Trying to unreact to a message in a channel user has not joined with pytest.raises(InputError): message_unreact(token1, m_id2, 1) # Trying to unreact to a message with no reacts of that type message_unreact(token1, m_id1, 1) with pytest.raises(InputError): message_unreact(token1, m_id1, 1) clear()
def test_edit_exceeds_1000_char(): clear() user = register_n_users(1) # Create a new channel channel = channels_create(user["token"], "channel01", is_public=True) # User sends a message message = message_send(user["token"], channel["channel_id"], "test message") edited_message = "a" * 1001 with pytest.raises(InputError): assert message_edit(user["token"], message["message_id"], edited_message)
def test_standup_start_standup_in_another_channel(): ''' Test that a standup can be started in another channel regardless of one started simultaneously in the first channel ''' clear() user = auth_register("*****@*****.**", "password", "Firstname", "Lastname") channel1 = channels_create(user['token'], "Channel1", True) channel2 = channels_create(user['token'], "Channel2", True) standup_start(user['token'], channel1['channel_id'], 1) # This causes error with pytest.raises(InputError): standup_start(user['token'], channel1['channel_id'], 1) # While this works fine standup_start(user['token'], channel2['channel_id'], 1) assert standup_active(user['token'], channel1['channel_id']) assert standup_active(user['token'], channel2['channel_id']) time.sleep(2)
def test_edit_continuous_send(): clear() user = register_n_users(1) channel_id = channels_create(user["token"], "channela", is_public=True)["channel_id"] for i in range(1, 50): message = message_send(user["token"], channel_id, "message " + str(i)) message_edit(user["token"], message["message_id"], "edited message " + str(i)) assert channel_messages( user["token"], channel_id, 0)["messages"][0]["message"] == "edited message " + str(i)
def test_message_send(): ''' Testing message_send function ''' clear() #Creating users to create channels user1 = auth_register("*****@*****.**", "user1pass", "user1", "last1", None) user2 = auth_register("*****@*****.**", "user2pass", "user2", "last2", None) token1 = user1['token'] token2 = user2['token'] #creating channels ch_id1 = channels_create(token1, "aGreatChannel", True)['channel_id'] ch_id2 = channels_create(token2, "yetAnotherChannel", False)['channel_id'] #error test with pytest.raises(InputError): #message too long message_send(token1, ch_id1, 'h' * 1001) with pytest.raises(AccessError): #user not in channel message_send(token1, ch_id2, "ilegal") #creating channel messages message_send(token1, ch_id1, 'h' * 1000) message_send(token1, ch_id1, 'hey') message_send(token2, ch_id2, "hello") message_send(token2, ch_id2, "hello") message_send(token2, ch_id2, "hello") #checking messages have been added print(channel_messages(token1, ch_id1, 0)) assert len(channel_messages(token1, ch_id1, 0)['messages']) == 2 assert len(channel_messages(token2, ch_id2, 0)['messages']) == 3
def test_authorised_person_not_in_channel(): '''test for access error''' reset_data() user1 = auth_register("*****@*****.**", "helloworld", "luc", "zhou") user2 = auth_register("*****@*****.**", "hellocse", "jiaqi", "zhu") user3 = auth_register("*****@*****.**", "thisissample", "first", "last") test_channel = channels.channels_create(user2['token'], "New Channel", True) with pytest.raises(AccessError): channel.channel_invite(user1['token'], test_channel['channel_id'], user3['u_id'])
def test_standup_start_success(): """Tests success case for standup_start""" clear() valid_user = auth_register("*****@*****.**", "validPassword", "Validate", "Me") new_channel = channels_create(valid_user["token"], "new_channel", False) result = standup_start(valid_user["token"], new_channel["channel_id"], 3) result_truncated = truncate(result["time_finish"], 0) current_time = int(time.time()) correct_time_finish = current_time + 3 correct_time_truncated = truncate(correct_time_finish, 0) assert result_truncated == correct_time_truncated time.sleep(3)
def test_success_removeowner(): '''test for success''' reset_data() owner = auth_register("*****@*****.**", "helloworld", "Cool", "Man") test_channel = channels.channels_create(owner['token'], "TTress", True) channel_id = test_channel['channel_id'] new_owner = auth_register("*****@*****.**", "avengers", "Natasha", "Romanova") channel.channel_addowner(owner['token'], channel_id, new_owner['u_id']) assert channel.channel_removeowner(owner['token'], channel_id, new_owner['u_id']) == {}
def test_create_more_than_one_channel(): ''' Testing when more than one channel is being created. ''' clear() new_user = auth_register("*****@*****.**", "password", "Firstname", "Lastname") user_token = new_user.get("token") new_channel_id1 = channels_create(user_token, "channel1", True) new_channel_id2 = channels_create(user_token, "channel2", True) new_channel_id3 = channels_create(user_token, "channel3", True) new_channel_id4 = channels_create(user_token, "channel4", True) list_of_channels = channels_list(user_token).get('channels') assert list_of_channels[0]["channel_id"] == new_channel_id1["channel_id"] assert list_of_channels[0]["name"] == "channel1" assert list_of_channels[1]["channel_id"] == new_channel_id2["channel_id"] assert list_of_channels[1]["name"] == "channel2" assert list_of_channels[2]["channel_id"] == new_channel_id3["channel_id"] assert list_of_channels[2]["name"] == "channel3" assert list_of_channels[3]["channel_id"] == new_channel_id4["channel_id"] assert list_of_channels[3]["name"] == "channel4"
def test_unpin_invalid_msg_id(): ''' Testing for an invalid message ID. ''' clear() user_1 = auth_register("*****@*****.**", "password", "User_1", "User_last_1") channel_1 = channels_create(user_1.get('token'), 'channel_1', True) message_info = message_send(user_1.get('token'), channel_1.get('channel_id'), 'Hello world') message_pin(user_1.get('token'), message_info.get('message_id')) with pytest.raises(InputError): message_unpin(user_1.get('token'), 'invalid_id')