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'], "....................")
