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_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_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_message_1001(channel_with_user): sender = channel_with_user invalid_message = "*" * 1001 assert len(invalid_message) == 1001 with pytest.raises(InputError): message_send(sender['token'], sender['c_id'], invalid_message)
def test_invalid_message_id(channel_with_user): owner = channel_with_user message_send(owner['token'], owner['c_id'], "Test Message 1") invalid_message_id = -1 with pytest.raises(InputError): message_remove(owner['token'], invalid_message_id)
def test_invalid_message_id(register_login, create_channel): owner = register_login owner_c_id = create_channel['c_id'] message_send(owner['token'], owner_c_id, "New Message") invalid_message_id = -1 with pytest.raises(AccessError): message_edit(owner['token'], invalid_message_id, "Edit Message")
def test_invalid_sender(channel_with_user): owner = channel_with_user # Seperate user who is not in the channel auth_register("*****@*****.**", "password", "Firstname", "Lastname") invalid_sender = auth_login("*****@*****.**", "password") with pytest.raises(AccessError): message_send(invalid_sender['token'], owner['c_id'], "Test Message")
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_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_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_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_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_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 message_send_flask(): payload = request.get_json() token = payload['token'] channel_id = int(payload['channel_id']) message = payload['message'] return dumps(m.message_send(token, channel_id, message))
def test_invalid_already_unpinned(channel_user_message_pin): owner = channel_user_message_pin unpinned_message = message_send(owner['token'], owner['c_id'], "Unpinned message") # Unpin the same message with pytest.raises(InputError): message_unpin(owner['token'], unpinned_message['message_id'])
def test_unreact_noreacts(register_login): user = register_login token = user['token'] is_public = True # creating public channel channel_id = channels_create(token, "Channel", is_public) # send a message but no reacts message_example = 'hello anto' message = message_send(token, channel_id['channel_id'], message_example) message_id = message['message_id'] react_id = 1 with pytest.raises(InputError): message_unreact(token, message_id, react_id)
def create_messages(channel_with_user, get_current_time): owner = channel_with_user timestamp = get_current_time # Create 60 messages in the owner's channel # To make this black-box, a copy is created so data is not referred to messages = [] i = 0 while i < 60: current_message = 'Example Message ' + str(i) message_send(owner['token'], owner['c_id'], current_message) messages.append({ 'message_id': i, 'u_id': 0, 'message': current_message, 'time_created': timestamp }) i += 1 return 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_unauthorised_user_message(register_login, create_channel): owner = register_login owner_c_id = create_channel['c_id'] owner_m_id = message_send(owner['token'], owner_c_id, "New Message")['message_id'] # creating a new user who isnt the owner of the channel, and did not create a message auth_register("*****@*****.**", "password2", "Richard2", "Shen2") user_2 = auth_login("*****@*****.**", "password2") channel_join(user_2['token'], owner_c_id) # should raise an AccessError since the new user is not an owner of the channel and didn't create the message with pytest.raises(AccessError): message_edit(user_2['token'], owner_m_id, "Edited Message")
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_message_1000(channel_with_user, get_current_time): sender = channel_with_user timestamp = get_current_time valid_message = "*" * 1000 message_send(sender['token'], sender['c_id'], valid_message) messages = channel_messages(sender['token'], sender['c_id'], 0)['messages'] assert messages == [ { 'message_id': 0, 'u_id': 0, 'message': valid_message, 'time_created': timestamp, 'reacts': [ { 'react_id': 0, 'u_ids': [], 'is_this_user_reacted': False, } ], 'is_pinned': False, }, ]
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_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_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_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 channel_user_message(): clear() flockr_owner = auth_register("*****@*****.**", "password", "John", "Doe") auth_register("*****@*****.**", "password", "Firstname", "Lastname") owner = auth_login("*****@*****.**", "password") public = True c_id = channels_create(owner['token'], "Channel", public) message = message_send(owner['token'], c_id['channel_id'], "Test Message 1") return { 'u_id': owner['u_id'], 'token': owner['token'], 'flockr_owner_token': flockr_owner['token'], 'c_id': c_id['channel_id'], 'message_id': message['message_id'] }
def create_channel_and_message_react(register_login): # register a user and log them in so they have a token. user = register_login token = user['token'] is_public = True # creating public channel channel_id = channels_create(token, "Channel", is_public) # send a message and react it with react_id 1 message_example = 'hello anto' message = message_send(token, channel_id['channel_id'], message_example) message_id = message['message_id'] react_id = 1 message_react(token, message_id, react_id) 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_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_invalid_message_spaces(channel_with_user): sender = channel_with_user empty_message = " " with pytest.raises(InputError): message_send(sender['token'], sender['c_id'], empty_message)
def send_messages(channel_user): owner = channel_user # Messages to be used in search message_send(owner['token'], owner['c_id'], "Channel0 - Message 0") message_send(owner['token'], owner['c_id'], "channel0 z Message 1!") message_send(owner['token'], owner['c_id'], "....................")