def test_message_pin():
'''
Function tests for message_pin
'''
#Initialisation
global_var.initialise_all()
#Create users
owner = auth_functions.auth_register("*****@*****.**", "pass123", \
"Sally", "Bob")
assert owner == {"u_id": 0, "token": encode_token_for_u_id(0)}
owner_token = owner["token"]
user = auth_functions.auth_register("*****@*****.**", "pass123", \
"Rayden", "Smith")
token = user["token"]
#owner that creates the channel and so is the owner
channel = channel_functions.channels_create(owner_token, "Name", True)
channel_id = channel["channel_id"]
#user joins the channel
channel_functions.channel_join(token, channel_id)
#user sends 3 messages
assert funcs.message_send(token, channel_id, "This is a valid message") \
== {"message_id" : 0}
assert funcs.message_send(token, channel_id, \
"This is another valid message") == {"message_id" : 1}
assert funcs.message_send(owner_token, channel_id, \
"This is not your message") == {"message_id" : 2}
#Init finished
#A invalid token is sent to the function
# (A invalid user is trying to use the function)
with pytest.raises(AccessError, match="Invalid token"):
funcs.message_pin("111111", 0)
#A user is not an admin
with pytest.raises(ValueError, match="User is not an admin"):
funcs.message_pin(token, 0)
#A admin user successfully pins a message
assert funcs.message_pin(owner_token, 0) == {}
#Message is invalid based on message_id
with pytest.raises(ValueError, match="Message does not exist"):
funcs.message_pin(owner_token, -1)
#Message is already pinned
with pytest.raises(ValueError, match="Message is currently pinned"):
funcs.message_pin(owner_token, 0)
#Admin leaves channel
channel_functions.channel_leave(owner_token, channel_id)
#Admin is not a member of the channel
with pytest.raises(AccessError, match=\
"Authorised user is not a member of the channel"):
funcs.message_pin(owner_token, 1)
def test_search_multi_channel():
'''
Testing successful case of being able to obtain messages from multiple
channels that the user is apart of
'''
# Initialising
global_var.initialise_all()
# Creating user
user = auth_register('*****@*****.**', 'password', 'search', 'test')
token = get_user_token_by_u_id(user["u_id"])
# Creating channel 1
channel1 = channels_create(token, "chat1", True)
channel1_id = channel1["channel_id"]
# Creating channel 2
channel2 = channels_create(token, "chat2", True)
channel2_id = channel2["channel_id"]
# Adding messages to channel
message_send(token, channel1_id, "121")
message_send(token, channel2_id, "321")
# Search
messages = search.search(token, '21')
# Checking if messages obtained
assert messages["messages"][0]["message"] == "121"
assert messages["messages"][0]["u_id"] == user["u_id"]
assert messages["messages"][1]["message"] == "321"
# Ensuring that no other messages are obtained
with pytest.raises(IndexError, match="list index out of range"):
message = messages["messages"][2]
def test_message_react():
'''
Function tests for message_react
'''
#Initialisation
global_var.initialise_all()
user = auth_functions.auth_register("*****@*****.**", "pass123", \
"Rayden", "Smith")
token = user["token"]
user_2 = auth_functions.auth_register("*****@*****.**", "password", \
"Bob", "Sally")
token_2 = user_2["token"]
#User creates a channel
channel = channel_functions.channels_create(token, "Name", True)
channel_id = channel["channel_id"]
#user sends 3 messages
assert funcs.message_send(token, channel_id, "This is a valid message") \
== {"message_id" : 0}
assert funcs.message_send(token, channel_id, \
"This is another valid message") == {"message_id" : 1}
assert funcs.message_send(token, channel_id, \
"This is your message") == {"message_id" : 2}
#Initialisation finished
# User not a member of channel
with pytest.raises(AccessError, match=\
"Authorised user is not a member of the channel"):
funcs.message_react(token_2, 0, LIKE_REACT)
channel_functions.channel_join(token_2, channel_id)
#An invalid token is sent to the function
with pytest.raises(AccessError, match="Invalid token"):
funcs.message_react("111111", 0, LIKE_REACT)
#A user successfully reacts
assert funcs.message_react(token, 0, LIKE_REACT) == {}
#A user successfully reacts - with a different react (Not implemented in frontend)
assert funcs.message_react(token, 0, HEART_REACT) == {}
#Another user also reacts to the same message
assert funcs.message_react(token_2, 0, LIKE_REACT) == {}
#An user tries to react to a invalid message based on message_id
with pytest.raises(ValueError, match="Message does not exist"):
funcs.message_react(token, -1, LIKE_REACT)
#An user tries to react to a message already reacted to
with pytest.raises(ValueError, match="Message contains an active react"):
funcs.message_react(token, 0, LIKE_REACT)
#An user uses a invalid react id
with pytest.raises(ValueError, match="Invalid React ID"):
funcs.message_react(token, 1, -1)
def test_message_remove():
''' Function tests for message_remove '''
#Initialisation
global_var.initialise_all()
assert global_var.data["users"] == []
#Create users
owner = auth_functions.auth_register("*****@*****.**", "pass123", \
"Sally", "Bob")
owner_token = owner["token"]
user = auth_functions.auth_register("*****@*****.**", "pass123", \
"Rayden", "Smith")
token = user["token"]
assert global_var.data["users"] != []
#owner creates a channel and so is the owner
channel = channel_functions.channels_create(owner_token, "Name", True)
assert channel == {"channel_id": 0}
channel_id = channel["channel_id"]
#user joins the channel
channel_functions.channel_join(token, channel_id)
#3 messages are sent
assert funcs.message_send(token, channel_id, "This is a valid message") \
== {"message_id" : 0}
assert funcs.message_send(token, channel_id, \
"This is another valid message") == {"message_id" : 1}
assert funcs.message_send(owner_token, channel_id, \
"This is not your message") == {"message_id" : 2}
#Initialisation finished
#A invalid token is sent to the function
with pytest.raises(AccessError, match="Invalid token"):
funcs.message_remove("111111", 0)
#owner successfully removes a message
assert funcs.message_remove(owner_token, 0) == {}
# As message was removed, it can not be removed again
with pytest.raises(ValueError, match="Message does not exist"):
funcs.message_remove(owner_token, 0)
#user successfully removes his own message
assert funcs.message_remove(token, 1) == {}
#A owner tries to remove a invalid message based on message_id
with pytest.raises(ValueError, match="Message does not exist"):
funcs.message_remove(owner_token, -1)
#A user tries to remove a invalid message based on message_id
with pytest.raises(ValueError, match="Message does not exist"):
funcs.message_remove(token, -1)
#user is unable to remove a message not his/her's
with pytest.raises(AccessError, match="User does not have permission"):
funcs.message_remove(token, 2)
def end_standup(self, token):
self.in_standup = False
self.standup_end = None
message = ""
for m in self.standup_messages:
line = ': '.join([m['user'], m['message']])
message = '\n'.join([message, line])
self.standup_messages = []
msg.message_send(token, self.id, message)
def test_search_one():
'''
Testing successful case for a search for one message
'''
# Initialising
global_var.initialise_all()
# Creating user
user = auth_register('*****@*****.**', 'password', 'search', 'test')
token = get_user_token_by_u_id(user["u_id"])
# Creating channel
channel = channels_create(token, "chat", True)
channel_id = channel["channel_id"]
# Adding messages to channel
message_send(token, channel_id, "121")
message_send(token, channel_id, "321")
message_send(token, channel_id, "342")
message_send(token, channel_id, "499")
# Searching message
messages = search.search(token, '99')
# Checking if message obtained
assert messages["messages"][0]["message"] == "499"
assert messages["messages"][0]["u_id"] == user["u_id"]
# Ensuring that no other messages are obtained
with pytest.raises(IndexError, match="list index out of range"):
message = messages["messages"][1]
def message_send():
'''
Send a message from authorised_user to the channel specified by channel_id
'''
token = request.form.get("token")
channel_id = to_int(request.form.get("channel_id"))
msg = request.form.get("message")
return dumps(message.message_send(token, channel_id, msg))
def test_channel_invite():
'''
Testing for inviting a user to a channel
'''
#Initialisation
global_var.initialise_all()
# Create an user who owns the channel
user1 = auth_register("*****@*****.**", "password123", \
"Rayden", "Smith")
token_1 = user1["token"]
# Create user that is invited to channel
user2 = auth_register("*****@*****.**", "thisisapassword", \
"Bob", "Sally")
token_2 = user2["token"]
userid_2 = user2["u_id"]
# Create user that will not be part of channel
user3 = auth_register("*****@*****.**", "arandompassword", \
"Coen", "Kevin")
token_3 = user3["token"]
# Create a channel
channel = func.channels_create(token_1, "TestChannel1", True)
channel_id = channel["channel_id"]
# Initialisation finished
# User2 is successfully invited to channel
assert func.channel_invite(token_1, channel_id, userid_2) == {}
# If the invite was successful, user2 can send a message
assert message_send(token_2, channel_id, "A successful message") \
== {"message_id" : 0}
# User leaves the channel
assert func.channel_leave(token_2, channel_id) == {}
# User is not invited if given an invalid token
with pytest.raises(AccessError, match="Invalid token"):
func.channel_invite("12345", channel_id, userid_2)
# User is not inivited if given an invalid channel_id
with pytest.raises(ValueError, match="Channel does not exist"):
func.channel_invite(token_1, 100, userid_2)
# Inviting user is not apart of the channel
with pytest.raises(AccessError, \
match="Authorised user is not a member of the channel"):
func.channel_invite(token_3, channel_id, userid_2)
# If user being invited is not an user
with pytest.raises(ValueError, match="Invalid User ID"):
func.channel_invite(token_1, channel_id, 111111)
def test_channel_leave():
'''
Function tests for channel_leave
'''
#Initialisation
global_var.initialise_all()
user1 = auth_register("*****@*****.**", \
"valid_correct_password", "valid_correct_first_name", \
"valid_correct_last_name")
token1 = user1["token"]
#create a channel
channel = func.channels_create(token1, "TestChannel", True)
channel_id = channel["channel_id"]
# Initialisation finished
# User is in channel so can send message
message_send(token1, channel_id, "can send message")
# User has left channel and so can't send messages
assert func.channel_leave(token1, channel_id) == {}
with pytest.raises(AccessError, \
match="Authorised user is not a member of the channel"):
message_send(token1, channel_id, "can't send message")
# The function is called using a invalid token
with pytest.raises(AccessError, match="Invalid token"):
func.channel_leave("12345", channel_id)
#If given an invalid channel_id
with pytest.raises(ValueError, match="Channel does not exist"):
func.channel_leave(token1, 100)
# The function is called using a invalid token
with pytest.raises(AccessError, match="Invalid token"):
func.channel_leave("12345", channel_id)
# User is already removed, but will not cause Error
assert func.channel_leave(token1, channel_id) == {}
def test_search_all():
'''
Testing search with a search for all messages request
'''
# Initialising
global_var.initialise_all()
# Creating user
user = auth_register('*****@*****.**', 'password', 'search', 'test')
token = get_user_token_by_u_id(user["u_id"])
# Creating channel
channel = channels_create(token, "chat", True)
channel_id = channel["channel_id"]
# Adding messages to channel
message_send(token, channel_id, "121")
message_send(token, channel_id, "321")
message_send(token, channel_id, "342")
message_send(token, channel_id, "499")
# Searching for all messages
messages = search.search(token, '')
# Checking if all messages are retrieved
assert messages["messages"][0]["message"] == "499"
assert messages["messages"][0]["u_id"] == user["u_id"]
assert messages["messages"][1]["message"] == "342"
assert not messages["messages"][1]["is_pinned"]
assert messages["messages"][2]["message"] == "321"
assert messages["messages"][3]["message"] == "121"
assert messages["messages"][3]["reacts"] == [
{
"react_id": LIKE_REACT,
"u_ids": [],
"is_this_user_reacted": False
},
{
"react_id": HEART_REACT,
"u_ids": [],
"is_this_user_reacted": False
}
]
# Ensuring that no messages after all messages retrieved
with pytest.raises(IndexError, match="list index out of range"):
message = messages["messages"][4]
def test_search_single_channel():
'''
Testing successful case for search with a channel having two messages
and returning two messages
'''
# Initialising
global_var.initialise_all()
# Creating user
user = auth_register('*****@*****.**', 'password', 'search', 'test')
token = get_user_token_by_u_id(user["u_id"])
user2 = auth_register('*****@*****.**', 'password', 'search', 'test')
token2 = get_user_token_by_u_id(user2["u_id"])
# Creating channel
channel = channels_create(token, "chat", True)
channel_id = channel["channel_id"]
# Create channel from the second user which the searching user is not a
# member of
channels_create(token2, "chat", True)
# Adding messages to channel
message_send(token, channel_id, "121")
message_send(token, channel_id, "321")
message_send(token, channel_id, "342")
message_send(token, channel_id, "499")
# Search
messages = search.search(token, '21')
# Checking if messages are obtained
assert messages["messages"][0]["message"] == "321"
assert messages["messages"][0]["u_id"] == user["u_id"]
assert messages["messages"][1]["message"] == "121"
# Ensuring that no other messages are obtained
with pytest.raises(IndexError, match="list index out of range"):
message = messages["messages"][2]
def test_get_channel_by_message_id():
'''
Ensures get_channel_by_message_id returns the correct channel
'''
# Initalise
global_var.initialise_all()
# Creating a user
user = auth.auth_register("*****@*****.**", "pass123", "Raydon", "Smith")
token = user["token"]
# Create a channel
channel = channel_functions.channels_create(token, "Channel 1", True)
channel_id = channel["channel_id"]
# Sending one message in channel
assert message_functions.message_send(token, channel_id, "Hello Everyone")\
== {"message_id" : 0}
# Check message obtain from first message
assert helpers.get_channel_by_message_id(0).id == channel_id
# Checking no such message_id
assert helpers.get_channel_by_message_id(-1) is None
def test_search_no_match():
'''
Testing search with a search for no such message
'''
# Initialising
global_var.initialise_all()
# Creating user
user = auth_register('*****@*****.**', 'password', 'search', 'test')
token = get_user_token_by_u_id(user["u_id"])
# Creating channel
channel = channels_create(token, "chat", True)
channel_id = channel["channel_id"]
# Adding messages to channel
message_send(token, channel_id, "121")
message_send(token, channel_id, "321")
message_send(token, channel_id, "342")
message_send(token, channel_id, "499")
assert search.search(token, 'hey') == {'messages': []}
def test_get_message_by_message_id():
'''
Ensures get_message_by_message_id returns the correct message
'''
# Initalise
global_var.initialise_all()
# Creating a user
user = auth.auth_register("*****@*****.**", "pass123", "Raydon", "Smith")
token = user["token"]
# Create channel
channel = channel_functions.channels_create(token, "Channel 1", True)
channel_id = channel["channel_id"]
# Send message
assert message_functions.message_send(token, channel_id, "Hello Everyone")\
== {"message_id" : 0}
# Assert that channel id is the same as given by message
assert helpers.get_message_by_message_id(0).message == "Hello Everyone"
# Checking no such message_id
assert helpers.get_message_by_message_id(-1) is None
def test_message_edit():
'''
Function tests for message_edit
'''
#Initialisation
global_var.initialise_all()
#Create users
owner = auth_functions.auth_register("*****@*****.**", "pass123", \
"Sally", "Bob")
owner_token = owner["token"]
user = auth_functions.auth_register("*****@*****.**", "pass123", \
"Rayden", "Smith")
token = user["token"]
#owner creates a channel and so is the owner
channel = channel_functions.channels_create(owner_token, "Name", True)
channel_id = channel["channel_id"]
#user joins the channel
channel_functions.channel_join(token, channel_id)
#3 messages are sent
assert funcs.message_send(token, channel_id, "This is a valid message") \
== {"message_id" : 0}
assert funcs.message_send(token, channel_id, \
"This is another valid message") == {"message_id" : 1}
assert funcs.message_send(owner_token, channel_id, \
"This is not your message") == {"message_id" : 2}
assert funcs.message_send(token, channel_id, \
"This is another valid message") == {"message_id" : 3}
#Init finished
#A owner edits a message
assert funcs.message_edit(owner_token, 0, "This is a valid edit") == {}
#A user edits his own message
assert funcs.message_edit(token, 1, "This is another valid edit") == {}
# A user edits a message with an empty string
assert funcs.message_edit(token, 1, "") == {}
assert funcs.message_edit(token, 3, " ") == {}
#A invalid token is sent to the function
with pytest.raises(AccessError, match="Invalid token"):
funcs.message_edit("111111", 0, "This is a valid edit")
#A owner tries to edit a invalid message based on message_id
with pytest.raises(ValueError, match="Message does not exist"):
funcs.message_edit(owner_token, -1, "This is a valid edit")
#A user tries to edit a invalid message based on message_id
with pytest.raises(ValueError, match="Message does not exist"):
funcs.message_edit(token, -1, "A valid message edit")
#A user tries to edit a message not his
with pytest.raises(AccessError, match="User does not have permission"):
funcs.message_edit(token, 2, "This is a valid message")
#The edited message was too long
with pytest.raises(ValueError, match="Message length too long"):
funcs.message_edit(owner_token, 0, "1" + create_long_string())
import pytest
import server.other_functions as OF
import server.token_functions as TF
import server.channel_functions as CF
import server.channel_helper_functions as CHF
import server.message_functions as MF
from server.global_variables import reset_data
from server.auth_functions import auth_login, auth_logout, auth_register
from server.channel_functions import channels_create
reset_data()
A = auth_register("*****@*****.**", 'HoyaLee2019', 'Hoya', 'Lee')
Pub_channel = CF.channels_create(A['token'], 'Num0', 'True')
message = MF.message_send(A['token'], Pub_channel['channel_id'], "Hello",
18.11)
'''If token is invalid'''
def test_token_invalid():
token = None
query_str = 'hello'
with pytest.raises(TypeError):
OF.search(token, query_str)
'''Search successfully'''
def test_search_success():
def test_message_send():
''' Function tests for message_send '''
#Initialisation
global_var.initialise_all()
assert global_var.data["users"] == []
#Creates an user
user = auth_functions.auth_register("*****@*****.**", "pass123", \
"Rayden", "Smith")
assert user == {"u_id": 0, "token": encode_token_for_u_id(0)}
token = user["token"]
assert global_var.data["users"] != []
#User creates a channel
channel = channel_functions.channels_create(token, "ChannelName", True)
assert channel == {"channel_id": 0}
channel_id = channel["channel_id"]
#Initialisation finished
#User successfully sends message to created channel
assert funcs.message_send(token, channel_id, \
"This is a valid message") == {"message_id": 0}
#A invalid token is sent to the function
with pytest.raises(AccessError, match="Invalid token"):
funcs.message_send("111111", channel_id, "This is a valid message")
#The channel based on ID does not exist
with pytest.raises(ValueError, match="Invalid Channel ID"):
funcs.message_send(token, -1, "This is a valid message")
#Sending a message of length 1000 is valid
assert funcs.message_send(token, channel_id, create_long_string()) \
== {"message_id" : 1}
#A message of length greater than 1000
with pytest.raises(ValueError, match="Message length too long"):
funcs.message_send(token, channel_id, "1" + create_long_string())
#Thrown multiple errors, token error is caught first
with pytest.raises(AccessError, match="Invalid token"):
funcs.message_send("111111", -1, "1" + create_long_string())
#User leaves channel
channel_functions.channel_leave(token, channel_id)
#User cannot send message to channel he is not apart of
with pytest.raises(AccessError, \
match="Authorised user is not a member of the channel"):
funcs.message_send(token, channel_id, "This is a valid message")
def test_channel_messages():
'''
Function tests for channel_messages
'''
#Initialisation
global_var.initialise_all()
user1 = auth_register("*****@*****.**", "passworuser.d", \
"channel_messages", "test")
user_id1 = user1["u_id"]
token1 = user1["token"]
user2 = auth_register("*****@*****.**", "password", \
"channel_messages2", "test2")
token2 = user2["token"]
#create a channel
channel = func.channels_create(token1, "TestChannel", True)
channel_id = channel["channel_id"]
channel2 = func.channels_create(token1, "TestChannel2", True)
channel_id2 = channel2["channel_id"]
# Initialisation finished
# Start index is invalid as there are no message
with pytest.raises(ValueError, match="Start index is invalid"):
func.channel_messages(token1, channel_id, 1)
# send a message to the channel and check that return is correct
assert message_send(token1, channel_id, '1 message') == {"message_id": 0}
messages = func.channel_messages(token1, channel_id, 0)
assert messages["start"] == 0
assert messages["end"] == -1
assert messages["messages"][0]["message_id"] == 0
assert messages["messages"][0]["u_id"] == user1["u_id"]
assert messages["messages"][0]["message"] == "1 message"
assert not messages["messages"][0]["is_pinned"]
assert messages["messages"][0]["reacts"] == [{
"react_id": LIKE_REACT,
"u_ids": [],
"is_this_user_reacted": False
}, {
"react_id": HEART_REACT,
"u_ids": [],
"is_this_user_reacted": False
}]
# Check details return is changed when the message is reacted and pinned
message_react(token1, 0, 1)
message_pin(token1, 0)
messages = func.channel_messages(token1, channel_id, 0)
assert messages["messages"][0]["reacts"] == [{
"react_id": LIKE_REACT,
"u_ids": [0],
"is_this_user_reacted": True
}, {
"react_id": HEART_REACT,
"u_ids": [],
"is_this_user_reacted": False
}]
assert messages["messages"][0]["is_pinned"]
# send a message to the channel and check that return is correct
message_send(token1, channel_id, '2 message')
messages = func.channel_messages(token1, channel_id, 0)
assert messages["messages"][0]["message"] == "2 message"
assert messages["messages"][1]["message"] == "1 message"
# A total of 50 messages are sent
for i in range(3, 51):
message_send(token1, channel_id, f'{i} message')
messages = func.channel_messages(token1, channel_id, 0)
assert messages["start"] == 0
assert messages["end"] == -1
assert messages["messages"][0]["message"] == "50 message"
assert messages["messages"][49]["message"] == "1 message"
messages = func.channel_messages(token1, channel_id, 1)
assert messages["start"] == 1
assert messages["end"] == -1
assert messages["messages"][0]["message"] == "49 message"
assert messages["messages"][48]["message"] == "1 message"
for i in range(0, 125):
message_send(token1, channel_id2, f'{i}')
messages = func.channel_messages(token1, channel_id2, 0)
assert messages["start"] == 0
assert messages["end"] == 50
assert messages["messages"][0]["message"] == "124"
assert messages["messages"][49]["message"] == "75"
messages = func.channel_messages(token1, channel_id2, 50)
assert messages["start"] == 50
assert messages["end"] == 100
assert messages["messages"][0]["message"] == "74"
assert messages["messages"][49]["message"] == "25"
messages = func.channel_messages(token1, channel_id2, 100)
assert messages["start"] == 100
assert messages["end"] == -1
assert messages["messages"][0]["message"] == "24"
assert messages["messages"][24]["message"] == "0"
# Test exceptions
with pytest.raises(ValueError, match="Channel does not exist"):
func.channel_messages(token1, -1, 0)
with pytest.raises(AccessError, match="Invalid token"):
func.channel_messages("12345", channel_id, 0)
with pytest.raises(ValueError, match="Start index is invalid"):
func.channel_messages(token1, channel_id, 100)
with pytest.raises(AccessError, match=\
"Authorised user is not a member of the channel"):
func.channel_messages(token2, channel_id, 0)
