def test_channel_leave_invalid_channel(register_new_user): new_user = register_new_user channels_create(new_user['token'], "Test Channel 1", True) with pytest.raises(InputError): channel_leave(new_user['token'], 4)
def test_details_valid_after_invite(register_and_login_user): token = register_and_login_user channels_create(token, "test channel", True) auth_register("*****@*****.**", "password", "Lmao", "Bus") login = auth_login("*****@*****.**", "password") token = login['token'] channel_invite(token, 0, 1) result = channel_details(token, 0) assert result == { 'name': 'test channel', 'owner_members': [{ 'u_id': 0, 'name_first': 'Angus', 'name_last': 'Doe', 'profile_img_url': 'default.jpg', }], 'all_members': [ { 'u_id': 0, 'name_first': 'Angus', 'name_last': 'Doe', 'profile_img_url': 'default.jpg', }, { 'u_id': 1, 'name_first': 'Lmao', 'name_last': 'Bus', 'profile_img_url': 'default.jpg', }, ] }
def test_list_multiple_and_only_user(register_login_create_channel, register_login_user2): token = register_login_create_channel channels_create(token, "test2 channel", True) token2 = register_login_user2 channels_create(token2, "unretrieved channel", True) result = channels_list(token) assert result == { 'channels': [{ 'channel_id': 0, 'name': 'test channel', 'owner_members': [0], 'all_members': [0], 'is_public': True, 'time_finish': None, 'messages': [], }, { 'channel_id': 1, 'name': 'test2 channel', 'owner_members': [0], 'all_members': [0], 'is_public': True, 'time_finish': None, 'messages': [], }] }
def test_details_valid(register_and_login_user): token = register_and_login_user # Create another user and a channel before it to not retrieve it auth_register("*****@*****.**", "password", "Angus", "Doe") login = auth_login("*****@*****.**", "password") channels_create(login['token'], "ignore channel", True) channels_create(token, "test channel", True) result = channel_details(token, 1) assert result == { 'name': 'test channel', 'owner_members': [{ 'u_id': 0, 'name_first': 'Angus', 'name_last': 'Doe', 'profile_img_url': 'default.jpg', }], 'all_members': [{ 'u_id': 0, 'name_first': 'Angus', 'name_last': 'Doe', 'profile_img_url': 'default.jpg', }] }
def test_channel_leave_member(register_new_user): # Create the user new_user = register_new_user token = new_user['token'] # Create the channel public = True channels_create(token, "Test Channel 2", public) test_channel = channels_create(token, "Test Channel", public) c_id = test_channel['channel_id'] in_channel = True # Create a new user who joins the channel auth_register("*****@*****.**", "password1", "Bilson", "Doe") user2 = auth_login("*****@*****.**", "password1") token2 = user2['token'] channel_join(token2, c_id) # 2nd member leaves, check if they are in the channel channel_leave(token2, c_id) member_check = channel_details(token, c_id) in_channel = user2['u_id'] in member_check['all_members'] assert in_channel == False
def test_unauthorised_member(register_and_login_user): token = register_and_login_user channels_create(token, "test channel", True) auth_register("*****@*****.**", "password", "Abus", "Doe") user = auth_login("*****@*****.**", "password") token = user['token'] with pytest.raises(AccessError): channel_details(token, 0)
def register_login_create_channel(): clear() # register and login a user auth_register("*****@*****.**", "password", "Angus", "Doe") login = auth_login("*****@*****.**", "password") token = login['token'] # create channel using that user channels_create(token, "test channel", True) return token
def test_valid_token(register_and_login_user): token = register_and_login_user channels_create(token, "test channel", True) result = channels_listall(token) assert result == { 'channels': [{ 'channel_id': 0, 'name': 'test channel', 'owner_members': [0], 'all_members': [0], 'is_public': True, 'time_finish': None, 'messages': [], }] }
def test_invalid_token(register_login): token = register_login public = True c_id = channels_create(token['token'], "Channel", public) invalid_token = token_hash(1) with pytest.raises(AccessError): channel_addowner(invalid_token, c_id['channel_id'], token['u_id'])
def test_invalid_u_id(register_login): token = register_login public = True c_id = channels_create(token['token'], "Channel", public) invalid_u_id = -1 with pytest.raises(InputError): channel_addowner(token['token'], c_id['channel_id'], invalid_u_id)
def test_invalid_token(register_and_login_user): token = register_and_login_user private = False c_id = channels_create(token['token'], "Channel", private) invalid_token = token_hash(1) with pytest.raises(AccessError): channel_invite(invalid_token, c_id, token['u_id'])
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_flockr_owner(): clear() # Register and login the global owner auth_register("*****@*****.**", "password", "First", "Last") flockr_owner = auth_login("*****@*****.**", "password") # Register and login 2 other users auth_register("*****@*****.**", "password", "First", "Last") owner_1 = auth_login("*****@*****.**", "password") auth_register("*****@*****.**", "password", "First", "Last") owner_2 = auth_login("*****@*****.**", "password") # Create a channel for owner_1 public = True owner_1_c_id = channels_create(owner_1['token'], "Channel", public)['channel_id'] channel_join(owner_2['token'], owner_1_c_id) # Make owner_2 actually an owner channel_addowner(owner_1['token'], owner_1_c_id, owner_2['u_id']) # The flockr_owner removes owner_2 as an owner channel_removeowner(flockr_owner['token'], owner_1_c_id, owner_2['u_id']) details = channel_details(owner_1['token'], owner_1_c_id) assert len(details['owner_members']) == 1 assert details['owner_members'][0]['u_id'] == 1
def test_invalid_u_id(register_and_login_user): token = register_and_login_user private = False c_id = channels_create(token['token'], "Channel", private) invalid_u_id = -1 with pytest.raises(InputError): channel_invite(token['token'], c_id, invalid_u_id)
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_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 channels_create_flask(): payload = request.get_json() token = payload['token'] name = payload['name'] is_public = payload['is_public'] return dumps(cs.channels_create(token, name, is_public))
def test_invalid_token(register_new_user): new_user = register_new_user token = new_user['token'] public = True c_id = channels_create(token, "Test Channel", public) with pytest.raises(AccessError): channel_leave(token_hash(1), c_id)
def register_2_users_channel(): clear() # Create a dummy channel for coverage where code loops through channels owner = auth_register("*****@*****.**", "password", "Angus", "Doe") channels_create(owner['token'], "Dummy Channel", True) # Create a user who is flockr owner and is creating the channel c_id = channels_create(owner['token'], "Channel", True) member = auth_register("*****@*****.**", "password", "Bungus", "Two") channel_join(member['token'], c_id['channel_id']) return { 'c_id': c_id['channel_id'], 'owner': owner, 'member': member, }
def test_private_channel(register_login_user): owner = register_login_user # Register and login a new user who plans to join the channel auth_register("*****@*****.**", "password", "First", "Last") member = auth_login("*****@*****.**", "password") private = False c_id = channels_create(owner['token'], "Channel", private) with pytest.raises(AccessError): channel_join(member['token'], c_id['channel_id'])
def channel_with_user(): clear() auth_register("*****@*****.**", "password", "Firstname", "Lastname") user = auth_login("*****@*****.**", "password") public = True c_id = channels_create(user['token'], "Channel", public) return { 'u_id': user['u_id'], 'token': user['token'], 'c_id': c_id['channel_id'], }
def test_unretrieved_channel(register_login_create_channel, register_login_user2): token = register_login_create_channel token2 = register_login_user2 # create channel which should not be retrieved channels_create(token2, "unretrieved channel", True) result = channels_list(token) assert result == { 'channels': [{ 'channel_id': 0, 'name': 'test channel', 'owner_members': [0], 'all_members': [0], 'is_public': True, 'time_finish': None, 'messages': [], }] }
def test_channel_leave_unauthorised(register_new_user): new_user = register_new_user token = new_user['token'] public = True test_channel = channels_create(token, "Test Channel", public) c_id = test_channel['channel_id'] auth_register("*****@*****.**", "password1", "Bilson", "Doe") user2 = auth_login("*****@*****.**", "password1") with pytest.raises(AccessError): channel_leave(user2['token'], c_id)
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 channel_with_user(): # A user is registered, logged in and owns a channel clear() auth_register("*****@*****.**", "password", "Firstname", "Lastname") token = auth_login("*****@*****.**", "password") public = True c_id = channels_create(token['token'], "Channel", public) return { 'u_id': token['u_id'], 'token': token['token'], 'c_id': c_id['channel_id'], }
def test_invite_success(register_and_login_user): token_1 = register_and_login_user auth_register("*****@*****.**", "password2", "First2", "Last2") token_2 = auth_login("*****@*****.**", "password2") private = False c_id = channels_create(token_1['token'], 'User_1s Channel', private) channel_invite(token_1['token'], c_id['channel_id'], token_2['u_id']) details = channel_details(token_1['token'], c_id['channel_id']) assert details['all_members'] == [ {'u_id': 0, 'name_first': 'First', 'name_last': 'Last', 'profile_img_url': 'default.jpg'}, {'u_id': 1, 'name_first': 'First2', 'name_last': 'Last2', 'profile_img_url': 'default.jpg'} ]
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 test_second_user_added(register_login_user): token_1 = register_login_user auth_register("*****@*****.**", "password", "First", "Last") token_2 = auth_login("*****@*****.**", "password") public = True c_id = channels_create(token_1['token'], "Channel", public) channel_join(token_2['token'], c_id['channel_id']) details = channel_details(token_1['token'], c_id['channel_id']) assert details['all_members'] == [ {'u_id': 0, 'name_first': 'First', 'name_last': 'Last', 'profile_img_url': 'default.jpg'}, {'u_id': 1, 'name_first': 'First', 'name_last': 'Last', 'profile_img_url': 'default.jpg'} ]
def channel_with_2_owners(): clear() # The first user is automatically an owner auth_register("*****@*****.**", "password", "First", "Last") token_1 = auth_login("*****@*****.**", "password") public = True # Create user and channel to be ignored but to pass authorised user auth_register("*****@*****.**", "password", "John", "Doe") ignore_me = auth_login("*****@*****.**", "password") channels_create(ignore_me['token'], "Ignore Me", public) c_id = channels_create(token_1['token'], "Channel", public) # The second user is made an owner for test purposes auth_register("*****@*****.**", "password2", "First2", "Last2") token_2 = auth_login("*****@*****.**", "password2") channel_join(token_2['token'], c_id['channel_id']) channel_addowner(token_1['token'], c_id['channel_id'], token_2['u_id']) return {'token_1': token_1, 'c_id': c_id, 'token_2': token_2}
def test_add_owner_success(register_login): token = register_login public = True # Create channel to be ignored but considered when testing auth_register("*****@*****.**", "password", "ignore", "me") ignore_me = auth_login("*****@*****.**", "password") channels_create(ignore_me['token'], "IgnoreMe", public) c_id = channels_create(token['token'], "Channel", public) auth_register("*****@*****.**", "password", "First", "Last") token2 = auth_login("*****@*****.**", "password") channel_join(token2['token'], c_id['channel_id']) details = channel_details(token['token'], c_id['channel_id']) assert len(details['owner_members']) == 1 assert (details['owner_members'][0]['u_id']) == 0 channel_addowner(token['token'], c_id['channel_id'], token2['u_id']) details = channel_details(token['token'], c_id['channel_id']) assert len(details['owner_members']) == 2 assert details['owner_members'][1]['u_id'] == token2['u_id']