def test_successful_unreact_two_reacts(register_login, create_channel_and_message_react): token = register_login['token'] message_id = create_channel_and_message_react['message_id'] channel_id = create_channel_and_message_react['channel_id'] # u_id of 0 should be in u_ids list message_details = channel_messages(token, channel_id, 0)['messages'] check_react_uids = message_details[0]['reacts'] assert check_react_uids[0]['u_ids'] == [0] react_id = 1 message_unreact(token, message_id, react_id) # u_id of 0 should be removed from u_id list. message_details = channel_messages(token, channel_id, 0)['messages'] check_react_uids = message_details[0]['reacts'] assert check_react_uids[0]['u_ids'] == [] message_example = 'hello again anto' message = message_send(token, 0, message_example) message_id = message['message_id'] react_id = 1 message_react(token, message_id, react_id) message_details = channel_messages(token, channel_id, 0)['messages'] check_react_uids = message_details[1]['reacts'] assert check_react_uids[0]['u_ids'] == [0] react_id = 1 message_unreact(token, message_id, react_id) # u_id of 0 should be removed from u_id list. message_details = channel_messages(token, channel_id, 0)['messages'] check_react_uids = message_details[1]['reacts'] assert check_react_uids[0]['u_ids'] == []
def test_multiple_messages_success(channel_with_user): owner = channel_with_user # Ensure there's no messages in the channel to begin with messages = channel_messages(owner['token'], owner['c_id'], 0)['messages'] assert not messages # Assumption: No need to test whether a message has been sent with message_send as this would be covered by message_send functions # Send 2 messages message_to_remove = message_send(owner['token'], owner['c_id'], "Test Message 1") message_send(owner['token'], owner['c_id'], "Test Message 2") # Verify the message was sent inbetween creating and removing message = channel_messages(owner['token'], owner['c_id'], 0)['messages'] assert message[0]['message_id'] == 0 assert message[0]['u_id'] == 0 assert message[0]['message'] == 'Test Message 1' assert message[1]['message_id'] == 1 assert message[1]['u_id'] == 0 assert message[1]['message'] == 'Test Message 2' # Remove 1st message message_remove(owner['token'], message_to_remove['message_id']) # Verify that the 2nd message has become the first message in the channel message = channel_messages(owner['token'], owner['c_id'], 0)['messages'] assert message[0]['message_id'] == 1 assert message[0]['u_id'] == 0 assert message[0]['message'] == 'Test Message 2'
def test_multiple_channels(channel_user, send_messages): owner = channel_user ch_0_ms_0 = channel_messages(owner['token'], owner['c_id'], 0)['messages'][0] ch_0_ms_1 = channel_messages(owner['token'], owner['c_id'], 0)['messages'][1] # Create another channel which also contains messages public = True c_id_2 = channels_create(owner['token'], "Channel1", public)['channel_id'] # Messages in Channel1 to be used in search message_send(owner['token'], c_id_2, "Channel1 - Message 0") message_send(owner['token'], c_id_2, "Channel1 - Message 1") ch_1_ms_0 = channel_messages(owner['token'], c_id_2, 0)['messages'][0] ch_1_ms_1 = channel_messages(owner['token'], c_id_2, 0)['messages'][1] query_str = "Channel0" search_result = search(owner['token'], query_str) assert search_result == {'messages': [ch_0_ms_0, ch_0_ms_1]} query_str = "Channel1" search_result = search(owner['token'], query_str) assert search_result == {'messages': [ch_1_ms_0, ch_1_ms_1]}
def test_member_edits_own_message(register_login, create_channel): owner = register_login owner_c_id = create_channel['c_id'] # Creating a new user who is not the owner, and joins the channel as a member auth_register("*****@*****.**", "password2", "Richard2", "Shen2") user_2 = auth_login("*****@*****.**", "password2") channel_join(user_2['token'], owner_c_id) # Verify the new user is not an owner channel = channel_details(owner['token'], owner_c_id) assert user_2['u_id'] not in channel['owner_members'] # User 2's message id user_2_m_id = message_send(user_2['token'], owner_c_id, "Member's Message")['message_id'] # Ensure that it is user 2's message messages = channel_messages(user_2['token'], owner_c_id, 0)['messages'] assert user_2['u_id'] == messages[0]['u_id'] # User 2 edits the message new_message = "user_2 can edit their own message" message_edit(user_2['token'], user_2_m_id, new_message) # Ensure the message is edited messages = channel_messages(user_2['token'], owner_c_id, 0)['messages'] assert new_message == messages[0]['message']
def test_message_1000(channel_with_user, get_current_time): sender = channel_with_user current_timestamp = get_current_time later_timestamp = current_timestamp + 3 valid_message = "*" * 1000 # Queue up the message to be sent later message_sendlater(sender['token'], sender['c_id'], valid_message, later_timestamp) # Check that no messages have been sent yet assert not channel_messages(sender['token'], sender['c_id'], 0)['messages'] # Wait 5 seconds to see if messages have been sent (including buffer time) sleep(5) messages = channel_messages(sender['token'], sender['c_id'], 0)['messages'] assert messages == [ { 'message_id': 0, 'u_id': 0, 'message': valid_message, 'time_created': later_timestamp, 'reacts': [{ 'react_id': 0, 'u_ids': [], 'is_this_user_reacted': False, }], 'is_pinned': False, }, ]
def test_multiple_edits(register_login, create_channel): owner = register_login owner_c_id = create_channel['c_id'] # 3 messages are created, the 2nd and 3rd will be edited message_send(owner['token'], owner_c_id, "Message 1")['message_id'] edit_request_1 = message_send(owner['token'], owner_c_id, "Message 2")['message_id'] edit_request_2 = message_send(owner['token'], owner_c_id, "Message 3")['message_id'] # Edit the 2nd message edited_message = "Edited Message 2" message_edit(owner["token"], edit_request_1, edited_message) # Check the 2nd message was editied correctly updated_message = channel_messages(owner['token'], owner_c_id, 0)['messages'][1]['message'] assert edited_message == updated_message # Edit the 3rd Message edited_message = "Edited Message 3" message_edit(owner["token"], edit_request_2, edited_message) # Check the 3rd message was editied correctly updated_message = channel_messages(owner['token'], owner_c_id, 0)['messages'][2]['message'] assert edited_message == updated_message
def test_invalid_channel_id(channel_with_user, create_messages): owner = channel_with_user invalid_c_id = -1 with pytest.raises(InputError): channel_messages(owner['token'], invalid_c_id, 2)
def test_flockr_owner_remover(channel_with_user): clear() # Creating the flockr owner auth_register("*****@*****.**", "flockr_ownerpassword", "flockr_ownerFirstname", "flockr_ownerLastname") flockr_owner = auth_login("*****@*****.**", "flockr_ownerpassword") # Creating the owner and their own channel auth_register("*****@*****.**", "ownerpassword", "ownerFirstname", "ownerLastname") owner = auth_login("*****@*****.**", "ownerpassword") public = True channel_id = channels_create(owner['token'], "Channel", public) # Creating the message via the owner message_id = message_send(owner['token'], channel_id['channel_id'], "Test Message 1") message = channel_messages(owner['token'], channel_id['channel_id'], 0)['messages'] # assert message == [ # {'message_id': 0, 'u_id': 1, 'message': 'Test Message 1', 'time_created': timestamp} # ] assert message[0]['message_id'] == 0 assert message[0]['u_id'] == 1 assert message[0]['message'] == 'Test Message 1' # Removing the message via the flockr owner message_remove(flockr_owner['token'], message_id['message_id']) messages = channel_messages(owner['token'], channel_id['channel_id'], 0)['messages'] assert not messages
def test_sender_message_remove_success(channel_with_user, ): owner = channel_with_user # Create second user who will send the message auth_register("*****@*****.**", "password", "First", "Last") sender = auth_login("*****@*****.**", "password") channel_join(sender['token'], owner['c_id']) # Ensure there's no messages in the channel to begin with messages = channel_messages(owner['token'], owner['c_id'], 0)['messages'] assert not messages # Send the message with a user other than the owner message_id = message_send(sender['token'], owner['c_id'], "Test Message") # Verify the message was sent inbetween creating and removing message = channel_messages(owner['token'], owner['c_id'], 0)['messages'] assert message[0]['message_id'] == 0 assert message[0]['u_id'] == 1 assert message[0]['message'] == 'Test Message' # Remove message message_remove(sender['token'], message_id['message_id']) # Verify that the message was removed messages = channel_messages(owner['token'], owner['c_id'], 0)['messages'] assert not messages
def test_unauthorised_user(channel_with_user, create_messages): owner = channel_with_user auth_register("*****@*****.**", "password", "Sam", "Wu") unaurthorised_user = auth_login("*****@*****.**", "password") with pytest.raises(AccessError): channel_messages(unaurthorised_user['token'], owner['c_id'], 5)
def test_message_sendtwolater_success(channel_with_user, get_current_time): sender = channel_with_user current_timestamp = get_current_time later_timestamp = current_timestamp + 3 # Ensure there's no messages in the channel to begin with assert not channel_messages(sender['token'], sender['c_id'], 0)['messages'] # Queue up multiple messages which are the same message_sendlater(sender['token'], sender['c_id'], "Test Message", later_timestamp) message_sendlater(sender['token'], sender['c_id'], "Test Message", later_timestamp) # Check that no messages have been sent yet assert not channel_messages(sender['token'], sender['c_id'], 0)['messages'] # Wait 4 seconds (buffer time) before checking if both messages were sent # with distinct message_id sleep(4) messages = channel_messages(sender['token'], sender['c_id'], 0)['messages'] print(messages) assert messages == [ { 'message_id': 0, 'u_id': 0, 'message': 'Test Message', 'time_created': later_timestamp, 'reacts': [{ 'react_id': 0, 'u_ids': [], 'is_this_user_reacted': False, }], 'is_pinned': False, }, { 'message_id': 1, 'u_id': 0, 'message': 'Test Message', 'time_created': later_timestamp, 'reacts': [{ 'react_id': 0, 'u_ids': [], 'is_this_user_reacted': False, }], 'is_pinned': False, }, ]
def test_multiple_channels(channel_with_user, get_current_time): sender = channel_with_user timestamp = get_current_time # Ensure there's no messages in the channel to begin with messages = channel_messages(sender['token'], sender['c_id'], 0)['messages'] assert not messages # Send the first message to the first channel message_send(sender['token'], sender['c_id'], "Test Message 1") messages = channel_messages(sender['token'], sender['c_id'], 0)['messages'] assert messages == [ { 'message_id': 0, 'u_id': 0, 'message': 'Test Message 1', 'time_created': timestamp, 'reacts': [ { 'react_id': 0, 'u_ids': [], 'is_this_user_reacted': False, } ], 'is_pinned': False, }, ] public = True channel_2 = channels_create(sender['token'], "Channel 2", public)['channel_id'] # Send the second message to the second channel message_send(sender['token'], channel_2, "Test Message 2") messages = channel_messages(sender['token'], channel_2, 0)['messages'] assert messages == [ { 'message_id': 1, 'u_id': 0, 'message': 'Test Message 2', 'time_created': timestamp, 'reacts': [ { 'react_id': 0, 'u_ids': [], 'is_this_user_reacted': False, } ], 'is_pinned': False, }, ]
def test_word_matches(channel_user, send_messages): owner = channel_user message_0 = channel_messages(owner['token'], owner['c_id'], 0)['messages'][0] message_1 = channel_messages(owner['token'], owner['c_id'], 0)['messages'][1] query_str = "channel" search_result = search(owner['token'], query_str) assert search_result == {'messages': [message_0, message_1]} query_str = "message" search_result = search(owner['token'], query_str) assert search_result == {'messages': [message_0, message_1]}
def test_sentence_matches(channel_user, send_messages): owner = channel_user message_0 = channel_messages(owner['token'], owner['c_id'], 0)['messages'][0] message_1 = channel_messages(owner['token'], owner['c_id'], 0)['messages'][1] query_str = "Channel0 - Message" search_result = search(owner['token'], query_str) assert search_result == {'messages': [message_0]} query_str = "Message 1!" search_result = search(owner['token'], query_str) assert search_result == {'messages': [message_1]}
def test_successful_unreact(register_login, create_channel_and_message_react): token = register_login['token'] message_id = create_channel_and_message_react['message_id'] channel_id = create_channel_and_message_react['channel_id'] # u_id of 0 should be in u_ids list message_details = channel_messages(token, channel_id, 0)['messages'] check_react_uids = message_details[0]['reacts'] assert check_react_uids[0]['u_ids'] == [0] react_id = 1 message_unreact(token, message_id, react_id) # u_id of 0 should be removed from u_id list. message_details = channel_messages(token, channel_id, 0)['messages'] check_react_uids = message_details[0]['reacts'] assert check_react_uids[0]['u_ids'] == []
def test_flockr_owner_permissions(register_login, create_channel): flockr_owner = register_login # Creates a new user who is the owner of a channel auth_register("*****@*****.**", "password2", "Richard2", "Shen2") user_2 = auth_login("*****@*****.**", "password2") c_id = channels_create(user_2["token"], "Channel", True)['channel_id'] # Create a new user who is not flockr owner, and is a member of a channel, # sends a message auth_register("*****@*****.**", "password3", "Richard3", "Shen3") user_3 = auth_login("*****@*****.**", "password3") channel_join(user_3['token'], c_id) channel_join(flockr_owner['token'], c_id) m_id = message_send(user_3['token'], c_id, "First Message")['message_id'] message_edit(flockr_owner['token'], m_id, "Edited Message") # Check the message was edited correctly updated_message = channel_messages(flockr_owner['token'], c_id, 0)['messages'][0]['message'] assert updated_message == "Edited Message"
def test_successful_react_two_messages(register_login, create_channel_and_message): token = register_login['token'] channel_id = create_channel_and_message['channel_id'] message_id = create_channel_and_message['message_id'] message_id2 = message_send(token, channel_id, "Message 2")['message_id'] # Checking if the first message is reacted to by the user react_id = 1 message_react(token, message_id, react_id) check_react_id = channel_messages(token, channel_id, 0)['messages'][0] check_react_id = check_react_id['reacts'] assert check_react_id[0]['react_id'] == 1 # Checking if the second message is reacted to by the user message_react(token, message_id2, react_id) check_react_id2 = channel_messages(token, channel_id, 0)['messages'][1] check_react_id2 = check_react_id2['reacts'] assert check_react_id2[0]['react_id'] == 1
def test_invalid_react_id(register_login, create_channel_and_message_react): token = register_login['token'] message_id = create_channel_and_message_react['message_id'] channel_id = create_channel_and_message_react['channel_id'] # u_id of 0 should be in u_ids list message_details = channel_messages(token, channel_id, 0)['messages'] check_react_uids = message_details[0]['reacts'] assert check_react_uids[0]['u_ids'] == [0] react_id = -1 with pytest.raises(InputError): message_unreact(token, message_id, react_id)
def test_owner_message_remove_success(channel_with_user): owner = channel_with_user # Ensure there's no messages in the channel to begin with messages = channel_messages(owner['token'], owner['c_id'], 0)['messages'] assert not messages # Send message message_id = message_send(owner['token'], owner['c_id'], "Test Message 1") # Verify the message was sent inbetween creating and removing message = channel_messages(owner['token'], owner['c_id'], 0)['messages'] assert message[0]['message_id'] == 0 assert message[0]['u_id'] == 0 assert message[0]['message'] == 'Test Message 1' # Remove message message_remove(owner['token'], message_id['message_id']) # Verify that the message was removed messages = channel_messages(owner['token'], owner['c_id'], 0)['messages'] assert not messages
def test_reused_message_id(channel_with_user): owner = channel_with_user # Ensure there's no messages in the channel to begin with messages = channel_messages(owner['token'], owner['c_id'], 0)['messages'] assert not messages # Send message message_id = message_send(owner['token'], owner['c_id'], "Test Message 1") message_remove(owner['token'], message_id['message_id']) # Failed message removal due to message already having been removed with pytest.raises(InputError): message_remove(owner['token'], message_id['message_id'])
def test_standup_send_1000(channel_with_user, standup): assert standup['is_active'] sender = channel_with_user valid_message = "*" * 1000 standup_send(sender['token'], sender['c_id'], valid_message) until_standup_finishes = 2 # seconds sleep(until_standup_finishes) messages = channel_messages(sender['token'], sender['c_id'], 0)['messages'] handle_str = user_profile(sender['token'], sender['u_id'])['user']['handle_str'] assert messages[0]['message'] == f"{handle_str}: {valid_message}"
def test_standup_send_multiple(channel_with_user, standup): assert standup['is_active'] sender = channel_with_user standup_send(sender['token'], sender['c_id'], "Test Message 1") standup_send(sender['token'], sender['c_id'], "Test Message 2") until_standup_finishes = 2 # seconds sleep(until_standup_finishes) messages = channel_messages(sender['token'], sender['c_id'], 0)['messages'] handle_str = user_profile(sender['token'], sender['u_id'])['user']['handle_str'] standup_messages = f"{handle_str}: Test Message 1\n" + f"{handle_str}: Test Message 2" assert messages[0]['message'] == standup_messages
def create_channel_and_message(register_login): # register a user and log them in so they have a token. user = register_login token = user['token'] is_public = True channel_id = channels_create(token, "Channel", is_public) message_example = 'test message 1' message = message_send(token, channel_id['channel_id'], message_example) message_details = channel_messages(token, channel_id['channel_id'], 0)['messages'] return { 'channel_id': channel_id['channel_id'], 'message_id': message['message_id'], 'reacts': message_details[0]['reacts'] }
def test_empty_message(register_login, create_channel): owner = register_login owner_c_id = create_channel['c_id'] # Create 3 messages message_send(owner['token'], owner_c_id, "Message 1")['message_id'] owner_m_id = message_send(owner['token'], owner_c_id, "Message 2")['message_id'] message_send(owner['token'], owner_c_id, "Message 3")['message_id'] all_messages = channel_messages(owner['token'], owner_c_id, 0)['messages'] message_1 = channel_messages(owner['token'], owner_c_id, 0)['messages'][0] message_3 = channel_messages(owner['token'], owner_c_id, 0)['messages'][2] # Deletes the 2nd message empty_message = "" assert len(all_messages) == 3 message_edit(owner["token"], owner_m_id, empty_message) # Ensure that the right message was removed all_messages = channel_messages(owner['token'], owner_c_id, 0)['messages'] assert len(all_messages) == 2 assert all_messages == [message_1, message_3]
def test_valid_start_and_channel_id(channel_with_user, create_messages): owner = channel_with_user messages = create_messages message_details = channel_messages(owner['token'], owner['c_id'], 3) fetch = { 'messages': [], 'start': message_details['start'], 'end': message_details['end'] } for message in message_details['messages']: if 3 <= message['message_id'] <= 53: fetch['messages'].append({'message_id': message['message_id'], 'u_id': message['u_id'], 'message': message['message'], 'time_created': 101}) assert fetch == {'messages': messages[3:53], 'start': 3, 'end': 53}
def test_valid_most_recent_message(channel_with_user, create_messages): owner = channel_with_user messages = create_messages message_details = channel_messages(owner['token'], owner['c_id'], 20) fetch = { 'messages': [], 'start': message_details['start'], 'end': message_details['end'] } for message in message_details['messages']: if 20 <= message['message_id'] <= 60: fetch['messages'].append({'message_id': message['message_id'], 'u_id': message['u_id'], 'message': message['message'], 'time_created': 101}) assert fetch == {'messages': messages[20:60], 'start': 20, 'end': -1}
def test_owner_edits_user_message(register_login, create_channel): owner = register_login owner_c_id = create_channel['c_id'] # Create a new user who is not the owner, and joins the channel as a member auth_register("*****@*****.**", "password2", "Richard2", "Shen2") user_2 = auth_login("*****@*****.**", "password2") channel_join(user_2['token'], owner_c_id) user_2_m_id = message_send(user_2['token'], owner_c_id, "User 2's Message")['message_id'] # Ensure that the owner can edit user 2's message owner_message = "Owner has authority to edit" message_edit(owner['token'], user_2_m_id, owner_message) message = channel_messages(owner['token'], owner_c_id, 0) assert owner_message == message['messages'][0]['message']
def test_standup_send_member(channel_with_user, standup): assert standup['is_active'] owner = channel_with_user # Login and register another user who will send the message auth_register('*****@*****.**', 'password', 'name_first', 'name_last') member = auth_login('*****@*****.**', 'password') channel_join(member['token'], owner['c_id']) standup_send(member['token'], owner['c_id'], "Member Message") until_standup_finishes = 2 # seconds sleep(until_standup_finishes) messages = channel_messages(member['token'], owner['c_id'], 0)['messages'] handle_str = user_profile(member['token'], member['u_id'])['user']['handle_str'] assert messages[0]['message'] == f"{handle_str}: Member Message"
def test_unauthorised_remover(channel_with_user): owner = channel_with_user # Ensure there's no messages in the channel to begin with messages = channel_messages(owner['token'], owner['c_id'], 0)['messages'] assert not messages # Send the first message message_id = message_send(owner['token'], owner['c_id'], "Test Message 1") # Register a second user auth_register("*****@*****.**", "password1", "unauthorised", "remover") unauthorised_remover = auth_login("*****@*****.**", "password1") channel_join(unauthorised_remover['token'], owner['c_id']) # Access Error, as the user trying to remove the message did not send it and is not an owner with pytest.raises(AccessError): message_remove(unauthorised_remover['token'], message_id['message_id'])
def test_successful_react_same_message_twice(register_login, create_channel_and_message): token = register_login['token'] channel_id = create_channel_and_message['channel_id'] message_id = create_channel_and_message['message_id'] react_id = 1 message_react(token, message_id, react_id) check_react_id = create_channel_and_message['reacts'] assert check_react_id[0]['react_id'] == 1 # Creating the second user, making them join the channel, create a message and react to it. auth_register("*****@*****.**", "password2", "Richard2", "Shen2") user2 = auth_login("*****@*****.**", "password2") user2_token = user2['token'] channel_join(user2_token, channel_id) message_react(user2_token, message_id, react_id) check_react_id2 = channel_messages(user2_token, channel_id, 0)['messages'] check_react_id2 = check_react_id2[0]['reacts'] assert check_react_id2[0]['u_ids'] == [0, 1]