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_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_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_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_invalid_owner_remove_2(channel_with_2_owners): owner = channel_with_2_owners auth_register("*****@*****.**", "password", "First", "Last") not_owner = auth_login("*****@*****.**", "password") channel_join(not_owner['token'], owner['c_id']['channel_id']) with pytest.raises(AccessError): channel_removeowner(not_owner['token'], owner['c_id']['channel_id'], owner['token_2']['u_id'])
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 test_unauthorised_user_pin(channel_user_message_pin): owner = channel_user_message_pin auth_register("*****@*****.**", "password", "Firstname", "Lastname") member = auth_login("*****@*****.**", "password") channel_join(member['token'], owner['c_id']) owner_channel = channel_details(owner['token'], owner['c_id']) assert member['u_id'] not in owner_channel['all_members'] with pytest.raises(AccessError): message_unpin(member['token'], owner['message_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 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_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 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_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_invalid_owner_add(register_login): # Register the first user who is the owner of the channel token = register_login public = True c_id = channels_create(token['token'], "Channel", public) # Create a second user auth_register("*****@*****.**", "password2", "Richard2", "Shen2") token2 = auth_login("*****@*****.**", "password2") # Create a third user auth_register("*****@*****.**", "password3", "Richard3", "Shen3") token3 = auth_login("*****@*****.**", "password3") # Make both new users join the channel channel_join(token2['token'], c_id['channel_id']) channel_join(token3['token'], c_id['channel_id']) details = channel_details(token['token'], c_id['channel_id']) assert details['all_members'][1]['u_id'] == 1 # Should raise AccessError if the newly joined member tries to make the other member an owner with pytest.raises(AccessError): channel_addowner(token3['token'], c_id['channel_id'], token2['u_id'])
def test_is_flockr_owner(register_login): # Creating the flockr owner, which is the first user to be registered flockr_owner = register_login flockr_token = flockr_owner['token'] # Creating a new user who will be the channel owner auth_register("*****@*****.**", "ownerpassword", "ownerRichard", "ownerShen") owner = auth_login("*****@*****.**", "ownerpassword") public = True c_id = channels_create(owner['token'], "Channel", public) # Creating a new user who will be just a member of the channel auth_register("*****@*****.**", "memberpassword", "memberRichard", "memberShen") member = auth_login("*****@*****.**", "memberpassword") channel_join(member['token'], c_id['channel_id']) # Making the member the owner via the permissions of the flockr owner channel_addowner(flockr_token, c_id['channel_id'], member['u_id']) details = channel_details(owner['token'], c_id['channel_id']) assert details['owner_members'][1]['u_id'] == member['u_id']
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]
def test_flockr_owner(register_login_user): # Keep the flockr owner seperate from channel owners flockr_owner = register_login_user # Register and login another user who is an owner auth_register("*****@*****.**", "password", "First", "Last") owner = auth_login("*****@*****.**", "password") # This owner then creates a channel private = False owner_c_id = channels_create(owner['token'], "Owner Channel", private)['channel_id'] # Flockr owner joins a channel channel_join(flockr_owner['token'], owner_c_id) details = channel_details(owner['token'], owner_c_id) assert details['all_members'] == [ {'u_id': 1, 'name_first': 'First', 'name_last': 'Last', 'profile_img_url': 'default.jpg'}, {'u_id': 0, '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']
def test_user_already_in_channel(register_login_user): token = register_login_user public = True c_id = channels_create(token['token'], "Channel", public) with pytest.raises(AccessError): channel_join(token['token'], c_id['channel_id'])
def test_invalid_channel_id(register_login_user): token = register_login_user invalid_c_id = -1 with pytest.raises(InputError): channel_join(token['token'], invalid_c_id)
def channel_join_flask(): payload = request.get_json() token = payload['token'] channel_id = payload['channel_id'] return dumps(c.channel_join(token, channel_id))
def test_invalid_token(register_login_user): token = register_login_user public = True c_id = channels_create(token['token'], "Channel", public) with pytest.raises(AccessError): channel_join(token_hash(1), c_id['channel_id'])