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]
