def test_searching_multiple_channels():
'''search should find all messages containing the query string regardless of channel'''
andrew = auth_register("*****@*****.**", "password", "andrew", "taylor")
new_channel_a = channels_create(andrew['token'], "channel_a", True)
new_channel_b = channels_create(andrew['token'], "channel_b", True)
message_send(andrew['token'], new_channel_a['channel_id'],
f'this is a test message in channel a')
message_send(andrew['token'], new_channel_b['channel_id'],
f'this is a test message in channel b')
search_results = search(andrew['token'], 'this is a test message')
assert isinstance(search_results, dict)
assert len(search_results['messages']) == 2
def test_message_already_reacted(new_channel_and_user):
""" Test that if a user react to a message that has already been reacted"""
message = message_send(new_channel_and_user['token'],
new_channel_and_user['channel_id'], 'adcd')
message_react(new_channel_and_user['token'], message['message_id'], 1)
with pytest.raises(InputError):
message_react(new_channel_and_user['token'], message['message_id'], 1)
def test_message_unreact_no_reacts(new_channel_and_user):
""" Test that if a user try to unreact a message when there is no reacts in message"""
message = message_send(new_channel_and_user['token'],
new_channel_and_user['channel_id'], 'adc')
with pytest.raises(InputError):
message_unreact(new_channel_and_user['token'], message['message_id'],
1)
def test_search_for_multiple_messages():
'''searching with valid paramters and checking the returned object is correct
messages_sent is a dictionary of message_ids as keys the message_content as
the value. This is used to verify that the messages found match the messages
that were sent.
'''
andrew = auth_register("*****@*****.**", "password", "andrew", "taylor")
new_channel = channels_create(andrew['token'], "channel_1", True)
messages_sent = {}
for message_number in range(10):
message_content = f'this is message number {message_number}'
new_message_id = message_send(andrew['token'],
new_channel['channel_id'],
message_content)['message_id']
messages_sent[new_message_id] = message_content
search_results = search(andrew['token'], 'this is message number')
assert isinstance(search_results, dict)
assert len(search_results['messages']) == 10
for message in search_results['messages']:
assert isinstance(message, dict)
assert 'message_id' in message
assert isinstance(message['message_id'], int)
assert 'u_id' in message
assert isinstance(message['u_id'], int)
assert 'message' in message
assert isinstance(message['message'], str)
assert message['message'] == messages_sent[message['message_id']]
assert 'time_created' in message
assert isinstance(message['time_created'], int)
def test_message_unpin_norm(new_channel_and_user):
""" Test that if a legal use unpin a message"""
message = message_send(new_channel_and_user['token'],
new_channel_and_user['channel_id'], 'adcd')
message_specific = get_message_by_msg_id(message['message_id'])
assert not message_specific['is_pinned']
def test_message_unpin_not_member(new_channel_and_user,
new_channel_and_user_2):
""" Test that try to unpin a message by a user who is not one of members"""
message = message_send(new_channel_and_user['token'],
new_channel_and_user['channel_id'], 'adcd')
with pytest.raises(AccessError):
message_unpin(new_channel_and_user_2['token'], message['message_id'])
def test_message_already_unpinned(new_channel_and_user):
""" Test that try to unpin a message that has already been pinned"""
message = message_send(new_channel_and_user['token'],
new_channel_and_user['channel_id'], 'adcd')
with pytest.raises(InputError):
message_unpin(new_channel_and_user['token'], message['message_id'])
def test_editing_with_invalid_token(new_channel_and_user):
""" Tests that an access error is thrown when an an invalid token is used """
message = message_send(new_channel_and_user['token'],
new_channel_and_user['channel_id'], 'a')
with pytest.raises(AccessError):
message_edit('invalid token', message['message_id'],
'new message to replace existing message')
def test_message_unreact_invalid_react_id(new_channel_and_user):
""" Test that a legal user unreact a message but with invalid react_id"""
message = message_send(new_channel_and_user['token'],
new_channel_and_user['channel_id'], 'adcd')
message_react(new_channel_and_user['token'], message['message_id'], 1)
with pytest.raises(InputError):
message_unreact(new_channel_and_user['token'], message['message_id'],
0)
def test_message_react_user_not_in_channel(new_channel_and_user,
new_channel_and_user_2):
""" Test that if a user try to react a message when he/she is not in that channel"""
message = message_send(new_channel_and_user['token'],
new_channel_and_user['channel_id'], 'adcd')
with pytest.raises(InputError):
message_react(new_channel_and_user_2['token'], message['message_id'],
1)
def test_removing_message_as_owner(new_channel_and_user):
''' tests the sucessful removal of a message by the channel owner'''
author = auth_register("*****@*****.**", "password", "first_name1",
"last_name1")
channel_invite(new_channel_and_user['token'],
new_channel_and_user['channel_id'], author['u_id'])
message = message_send(author['token'], new_channel_and_user['channel_id'],
'a')
message_remove(new_channel_and_user['token'], message['message_id'])
def test_removing_authored_message(new_channel_and_user):
""" Tests the successful removal of a message from a user that sent it"""
author = auth_register("*****@*****.**", "password", "first_name1",
"last_name1")
channel_invite(new_channel_and_user['token'],
new_channel_and_user['channel_id'], author['u_id'])
message = message_send(author['token'], new_channel_and_user['channel_id'],
'a')
message_remove(author['token'], message['message_id'])
def test_channel_messages_invalid_start(channel_dav, user_dav):
# There is only one message inside the channel
msg_1 = message_send(user_dav['token'], channel_dav['channel_id'],
"message")
with pytest.raises(InputError):
assert channel_messages(user_dav['token'], channel_dav['channel_id'],
100)
def test_channel_messages_invalid_user(channel_dav, user_dav, user_chas):
# There is only one message inside the channel
msg_1 = message_send(user_dav['token'], channel_dav['channel_id'],
"message")
with pytest.raises(AccessError):
assert channel_messages(user_chas['token'], channel_dav['channel_id'],
0)
def test_sending_message_without_channel_access(new_channel_and_user):
"""Tests that a user sending a message to a channel
they do not have access to, throws an error
"""
unauthorized_user = auth_register("*****@*****.**", "password",
"first_name1", "last_name1")
with pytest.raises(AccessError):
assert message_send(unauthorized_user['token'],
new_channel_and_user['channel_id'], 'a')
def test_message_pin_not_owner(new_channel_and_user, new_channel_and_user_2):
""" Test that try to pin a message but not the owner"""
message = message_send(new_channel_and_user['token'],
new_channel_and_user['channel_id'], 'adcd')
channel_invite(new_channel_and_user['token'],
new_channel_and_user['channel_id'],
new_channel_and_user_2['u_id'])
with pytest.raises(InputError):
message_pin(new_channel_and_user_2['token'], message['message_id'])
def test_sending_many_messages(new_channel_and_user):
"""Sends 49 messages into a channel and checks the id has been incremented"""
for message_id in range(49):
message = message_send(new_channel_and_user['token'],
new_channel_and_user['channel_id'],
str(message_id))
assert isinstance(message, dict)
assert 'message_id' in message
assert isinstance(message['message_id'], int)
assert message['message_id'] == message_id
def test_searching_multiple_channels_with_no_access():
'''search should find all messages containing the query string THAT THE USER HAS ACCESS TO'''
andrew = auth_register("*****@*****.**", "password", "andrew", "taylor")
andrews_channel = channels_create(andrew['token'], "andrews channel",
False)
message_send(andrew['token'], andrews_channel['channel_id'],
'this is a test message in andrews channel')
john = auth_register("*****@*****.**", "password", "john", "smith")
johns_channel = channels_create(john['token'], "channel_b", False)
message_send(john['token'], johns_channel['channel_id'],
'this is a test message in johns channel')
andrews_search_results = search(andrew['token'], 'this is a test message')
assert isinstance(andrews_search_results, dict)
assert len(andrews_search_results['messages']) == 1
johns_search_results = search(john['token'], 'this is a test message')
assert isinstance(johns_search_results, dict)
assert len(johns_search_results['messages']) == 1
def test_editing_authored_message_with_empty_message(new_channel_and_user):
""" Tests replacing a message with an empty message removes the messages"""
author = auth_register("*****@*****.**", "password", "first_name1",
"last_name1")
channel_invite(new_channel_and_user['token'],
new_channel_and_user['channel_id'], author['u_id'])
message = message_send(author['token'], new_channel_and_user['channel_id'],
'a')
message_edit(author['token'], message['message_id'], '')
with pytest.raises(InputError):
message_edit(author['token'], message['message_id'], '')
def test_sending_long_message(new_channel_and_user):
""" Test sending a message that is just below the size limit
uses channel_messages to verify that the message has been recorded
assuming message ids start with 0, the first message ever will
have an id of 0
"""
message = message_send(new_channel_and_user['token'],
new_channel_and_user['channel_id'], 'a' * 1000)
assert isinstance(message, dict)
assert 'message_id' in message
assert isinstance(message['message_id'], int)
assert message['message_id'] == 0
def test_removing_a_message_unauthorized_user(new_channel_and_user):
"""Tests that an error is thrown when the user is not authorised to remove the message
A user is not authorised if they are not authorised to see the channel
"""
message = message_send(new_channel_and_user['token'],
new_channel_and_user['channel_id'], 'a')
unauthorized_user = auth_register("*****@*****.**", "password",
"first_name1", "last_name1")
with pytest.raises(AccessError):
assert message_remove(unauthorized_user['token'],
message['message_id'])
def test_message_unreact_norm(new_channel_and_user):
""" Test that a legal user unreat a peice of mesage when there is only one piece of message"""
message = message_send(new_channel_and_user['token'],
new_channel_and_user['channel_id'], 'adcd')
message_react(new_channel_and_user['token'], message['message_id'], 1)
message_unreact(new_channel_and_user['token'], message['message_id'], 1)
message_specific = get_message_by_msg_id(message['message_id'])
assert message_specific['reacts'] == [{
'is_this_user_reacted': True,
'react_id': 1,
'u_ids': []
}]
def test_message_unreact_ueser_not_react(new_channel_and_user,
new_channel_and_user_2):
""" Test that if a uer try to unreact a message which is not his/her reaction"""
message = message_send(new_channel_and_user['token'],
new_channel_and_user['channel_id'], 'adcd')
message_react(new_channel_and_user['token'], message['message_id'], 1)
channel_invite(new_channel_and_user['token'],
new_channel_and_user['channel_id'],
new_channel_and_user_2['u_id'])
with pytest.raises(InputError):
message_unreact(new_channel_and_user_2['token'], message['message_id'],
1)
def test_message_react_normal(new_channel_and_user):
""" Test that an legal user react a message"""
message = message_send(new_channel_and_user['token'],
new_channel_and_user['channel_id'], 'adcd')
message_react(new_channel_and_user['token'], message['message_id'], 1)
message_specific = get_message_by_msg_id(message['message_id'])
assert message_specific['reacts'] == [{
'react_id':
1,
'u_ids': [new_channel_and_user['u_id']],
'is_this_user_reacted':
True
}]
def test_removing_a_message_neither_author_nor_owner(new_channel_and_user):
"""Tests that an error is thrown when the user is not authorised to remove the message
A user is not authorised if they are
i not the author of the message and
ii: not an admin/owner of the chat
"""
not_author = auth_register("*****@*****.**", "password",
"first_name1", "last_name1")
message = message_send(new_channel_and_user['token'],
new_channel_and_user['channel_id'], 'a')
channel_invite(new_channel_and_user['token'],
new_channel_and_user['channel_id'], not_author['u_id'])
with pytest.raises(AccessError):
assert message_remove(not_author['token'], message['message_id'])
def test_channel_messages_num_messages(channel_dav, user_dav):
# Create couple messages
message_send(user_dav['token'], channel_dav['channel_id'], "Message")
message_send(user_dav['token'], channel_dav['channel_id'], "I love cs1531")
message_send(user_dav['token'], channel_dav['channel_id'], "Make it")
message_send(user_dav['token'], channel_dav['channel_id'], "can't do it")
# Test 0
# When the start index is 0
test_0 = channel_messages(user_dav['token'], channel_dav['channel_id'], 0)
assert test_0['start'] == 0
assert test_0['end'] == -1
assert len(test_0['messages']) == 4
# Test 1
# When the start index is 1
test_1 = channel_messages(user_dav['token'], channel_dav['channel_id'], 1)
assert test_1['start'] == 1
assert test_1['end'] == -1
assert len(test_1['messages']) == 3
def test_search_for_one_message():
'''searching with valid paramters and checking the returned object is correct'''
andrew = auth_register("*****@*****.**", "password", "andrew", "taylor")
new_channel = channels_create(andrew['token'], "channel_1", True)
new_message = message_send(andrew['token'], new_channel['channel_id'],
f'this is a test message')
search_results = search(andrew['token'], 'test message')
assert isinstance(search_results, dict)
assert len(search_results['messages']) == 1
message = search_results['messages'][0]
assert isinstance(message, dict)
assert 'message_id' in message
assert isinstance(message['message_id'], int)
assert message['message_id'] == new_message['message_id']
assert 'u_id' in message
assert isinstance(message['u_id'], int)
assert 'message' in message
assert isinstance(message['message'], str)
assert 'time_created' in message
assert isinstance(message['time_created'], int)
def test_sending_empty_message(new_channel_and_user):
""" Tests that an empty message will throw and error"""
with pytest.raises(InputError):
message_send(new_channel_and_user['token'],
new_channel_and_user['channel_id'], '')
def message_send_wsgi():
json = request.get_json()
return jsonify(
message_send(json['token'], int(int(json['channel_id'])),
json['message']))
def test_sending_with_invalid_token(new_channel_and_user):
""" Tests that an access error is thrown when an an invalid token is used """
with pytest.raises(AccessError):
message_send('invalid token', new_channel_and_user['channel_id'], 'a')
