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'])
