def test_mixed_success(create_input):
current_time = int(time.time())
message_send_v2(create_input[0][0]["token"],
create_input[1][0]["channel_id"],
"This is the first normal message")
assert len(
channel_messages_v2(create_input[0][0]["token"],
create_input[1][0]["channel_id"],
0)["messages"]) == 1
msg = message_sendlater_v1(create_input[0][1]["token"],
create_input[1][0]["channel_id"],
"Hey there, I'm from the past!",
current_time + 2)
assert type(msg) == dict
assert type(msg["message_id"]) == int
message_send_v2(create_input[0][2]["token"],
create_input[1][0]["channel_id"],
"This is the second normal message")
# Make sure delayed message has not been sent yet
msgs = channel_messages_v2(create_input[0][1]["token"],
create_input[1][0]["channel_id"], 0)["messages"]
assert len(msgs) == 2
# Wait 2.5 seconds and check again; delayed message should be there
time.sleep(2.5)
msgs = channel_messages_v2(create_input[0][1]["token"],
create_input[1][0]["channel_id"], 0)["messages"]
assert len(msgs) == 3
assert msgs[0]["message"] == "Hey there, I'm from the past!"
assert msgs[0]["time_created"] == current_time + 2
assert msgs[1]["message"] == "This is the second normal message"
assert msgs[1]["time_created"] == current_time
assert msgs[2]["message"] == "This is the first normal message"
assert msgs[2]["time_created"] == current_time
def test_two_tags():
clear_v1()
user1 = auth_register_v2("*****@*****.**", "finalpassword", "Eric",
"Zheng")
user2 = auth_register_v2("*****@*****.**", "validpassword", "Josh",
"Hatton")
channel1 = channels_create_v2(user1['token'], 'Channel 1', True)
channel_join_v2(user2['token'], channel1['channel_id'])
msg1str = "@ericzheng @joshhatton"
message_send_v2(user1['token'], channel1['channel_id'], msg1str)
assert notifications_get_v1(user1['token']) == {
'notifications': [{
'channel_id':
channel1['channel_id'],
'dm_id':
-1,
'notification_message':
f"ericzheng tagged you in Channel 1: {msg1str[0:20]}"
}]
}
assert notifications_get_v1(user2['token']) == {
'notifications': [{
'channel_id':
channel1['channel_id'],
'dm_id':
-1,
'notification_message':
f"ericzheng tagged you in Channel 1: {msg1str[0:20]}"
}]
}
def standup_timer(token, channel_id):
"""
Function is called a during threading,timer, where the time is given as length (x seconds standup period). At the end of length seconds, function will check the
biffered list of standup_send messages and packed them into one message. Then the message will be sent via the user in the specified channel_id
Other features of this function included clearing the ative standup list and removing buffered messages (that were already sent into a packaged message)
Parameters:
token (str) : token of the user that has called the standup
channel_id (int) : the channel_id the packaged message will be sent to
Returns:
None
"""
from src.message import message_send_v2
if "standup_buffer" in data and f"channel {channel_id}" in data[
"standup_buffer"]:
size = len(data["standup_buffer"][f"channel {channel_id}"])
packaged_message = ''
for msg in data["standup_buffer"][f"channel {channel_id}"]:
if msg == data["standup_buffer"][f"channel {channel_id}"][size -
1]:
packaged_message = packaged_message + msg
else:
packaged_message = packaged_message + msg + '\n'
del data["standup_buffer"][f"channel {channel_id}"]
message_send_v2(token, channel_id, packaged_message)
if data.get("active_standups") != None:
for i in data["active_standups"]:
if i["channel_id"] == channel_id:
data["active_standups"].remove(i)
def test_timeout(test_data):
a_data, b_data, c_data, a_ch_id = test_data
channel_join_v2(b_data["token"], a_ch_id)
channel_join_v2(c_data["token"], a_ch_id)
message_send_v2(a_data["token"], a_ch_id, "/u simple")
# scrambler sends "Unscramble this! xxxxx"
# scrambler should time out after 10 seconds
sleep(11)
# no message should be sent in between the timeout
assert channel_messages_v2(
a_data["token"], a_ch_id,
0)["messages"][0]["message"][:len("Unscramble this! "
)] == "Unscramble this! "
message_send_v2(a_data["token"], a_ch_id, "red")
message_send_v2(a_data["token"], a_ch_id, "green")
message_send_v2(a_data["token"], a_ch_id, "blue")
# should only be 5 total messages as unscrambler should stop listening after 10 secs
assert len(channel_messages_v2(a_data["token"], a_ch_id,
0)["messages"]) == 5
# should still work after timeout
message_send_v2(a_data["token"], a_ch_id, "/u simple")
assert channel_messages_v2(
a_data["token"], a_ch_id,
0)["messages"][0]["message"][:len("Unscramble this! "
)] == "Unscramble this! "
def test_message_send_message_too_long():
# InputError raised if message given is more than 1000 characters
clear_v1()
user = auth_register_v2('*****@*****.**', 'pasword24323132', 'Tinker', 'Bell')
channel = channels_create_v2(user['token'], 'Insert Title Here', True)
with pytest.raises(InputError):
message_send_v2(user['token'], channel['channel_id'], 'L'*1001)
def test_invalid_token():
""" Tests return of expected output when given a token that doesn't exist,
or if the user is not in the channel/dm.
"""
clear_v1()
# Token doesnt exist
user_1 = auth_register_v2('*****@*****.**', 'happydays1', 'Eric',
'Zheng')
with pytest.raises(AccessError):
notifications_get_v1(user_1['token'] + 'bug')
# User not in channel
user_2 = auth_register_v2('*****@*****.**', 'happydays2', 'Josh',
'Hatton')
channel_1 = channels_create_v2(user_1['token'], 'Channel 1', True)
user_2_handle = user_profile_v2(user_1['token'], user_2['auth_user_id'])
message_send_v2(user_1['token'], channel_1['channel_id'],
f"Hi @{user_2_handle['user']['handle_str']}")
assert notifications_get_v1(user_2['token']) == {'notifications': []}
# User not in dm
dm_1 = dm_create_v1(user_1['token'], [user_2['auth_user_id']])
user_3 = auth_register_v2('*****@*****.**', 'hihihi!!!', 'Bunny',
'Dong')
user_3_handle = user_profile_v2(user_1['token'], user_3['auth_user_id'])
message_senddm_v1(user_1['token'], dm_1['dm_id'],
f"Hello @{user_3_handle['user']['handle_str']}")
assert notifications_get_v1(user_3['token']) == {'notifications': []}
def test_message_send_invalid_channel_id():
# Test if InputError is raised when given invalid channel id
clear_v1()
user = auth_register_v2('*****@*****.**', 'password123', 'Terry', 'Wills')
channels_create_v2(user['token'], 'TERRYS CHANNEL', True)
with pytest.raises(InputError):
message_send_v2(user['token'], -1, 'anyone here?')
def test_dm(test_data):
a_data, b_data, c_data, a_ch_id = test_data
channel_join_v2(b_data["token"], a_ch_id)
channel_join_v2(c_data["token"], a_ch_id)
# Create the unscramble user
message_send_v2(a_data["token"], a_ch_id, "/u start")
us_id = None
for user in users_all_v1(a_data["token"])["users"]:
if user["name_first"] == "Sinister" and user[
"name_last"] == "Scrambler":
us_id = user["u_id"]
a_dm_id = dm_create_v1(
a_data["token"],
[b_data["auth_user_id"], c_data["auth_user_id"]])["dm_id"]
dm_invite_v1(a_data["token"], a_dm_id, us_id)
message_senddm_v1(a_data["token"], a_dm_id, "/u start")
# latest message should be the one above.
# scrambler shouldnt send any messages
assert dm_messages_v1(a_data["token"], a_dm_id,
0)["messages"][0]["message"] == "/u start"
message_senddm_v1(a_data["token"], a_dm_id, "/u leaderboard")
assert dm_messages_v1(a_data["token"], a_dm_id,
0)["messages"][0]["message"] == "/u leaderboard"
message_senddm_v1(a_data["token"], a_dm_id, "/u simple")
assert dm_messages_v1(a_data["token"], a_dm_id,
0)["messages"][0]["message"] == "/u simple"
def test_message_send_invalid_token():
# Test if AccessError is raised when given invalid token
clear_v1()
user = auth_register_v2('*****@*****.**', 'password1234', 'Harry', 'Lurr')
channel = channels_create_v2(user['token'], 'HARRYS CHANNEL', True)
with pytest.raises(AccessError):
message_send_v2(-2382732, channel['channel_id'], 'Poopoo')
def test_different_permissions_edit_remove():
clear_v1()
user_1 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a')
user_2 = auth_register_v2('*****@*****.**', 'bbbbbb', 'b', 'b')
user_3 = auth_register_v2('*****@*****.**', 'cccccc', 'c', 'c')
channel_1 = channels_create_v2(user_1['token'], 'Channel 1', True)
channel_invite_v2(user_1['token'], channel_1['channel_id'],
user_2['auth_user_id'])
channel_invite_v2(user_1['token'], channel_1['channel_id'],
user_3['auth_user_id'])
msg1 = message_send_v2(user_2['token'], channel_1['channel_id'],
'First Message')
msg2 = message_send_v2(user_2['token'], channel_1['channel_id'],
'Second Message')
assert len(
channel_messages_v2(user_1['token'], channel_1['channel_id'],
0)['messages']) == 2
assert message_edit_v2(user_1['token'], msg1['message_id'], '') == {}
assert len(
channel_messages_v2(user_1['token'], channel_1['channel_id'],
0)['messages']) == 1
assert channel_messages_v2(user_1['token'], channel_1['channel_id'],
0)['messages'][0]['message'] == "Second Message"
assert message_edit_v2(user_2['token'], msg2['message_id'], '') == {}
msg3 = message_send_v2(user_2['token'], channel_1['channel_id'],
'Third Message')
assert channel_messages_v2(user_1['token'], channel_1['channel_id'],
0)['messages'][0]['message'] == "Third Message"
with pytest.raises(AccessError):
message_edit_v2(user_3['token'], msg3['message_id'], '')
with pytest.raises(AccessError):
message_remove_v1(user_3['token'], msg3['message_id'])
assert channel_messages_v2(user_1['token'], channel_1['channel_id'],
0)['messages'][0]['message'] == "Third Message"
def test_multiple_messages_same_channel():
clear_v1()
user_1 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a')
channel_1 = channels_create_v2(user_1['token'], 'Channel 1', True)
msg1 = message_send_v2(user_1['token'], channel_1['channel_id'],
'Hello World!')
msg2 = message_send_v2(user_1['token'], channel_1['channel_id'], 'I')
msg3 = message_send_v2(user_1['token'], channel_1['channel_id'], 'Love')
msg4 = message_send_v2(user_1['token'], channel_1['channel_id'], 'COMP')
assert type(msg1) == dict
assert type(msg1['message_id']) == int
assert channel_messages_v2(user_1['token'], channel_1['channel_id'],
0)['messages'][0]['message'] == "COMP"
assert type(msg2) == dict
assert type(msg2['message_id']) == int
assert channel_messages_v2(user_1['token'], channel_1['channel_id'],
1)['messages'][0]['message'] == "Love"
assert type(msg3) == dict
assert type(msg3['message_id']) == int
assert channel_messages_v2(user_1['token'], channel_1['channel_id'],
2)['messages'][0]['message'] == "I"
assert type(msg4) == dict
assert type(msg4['message_id']) == int
assert channel_messages_v2(user_1['token'], channel_1['channel_id'],
3)['messages'][0]['message'] == "Hello World!"
assert msg1['message_id'] != msg2['message_id']
assert msg1 != msg3
assert msg1 != msg4
assert msg2 != msg3
assert msg2 != msg4
assert msg3 != msg4
assert len(
channel_messages_v2(user_1['token'], channel_1['channel_id'],
0)['messages']) == 4
def test_message_longer_than_one_thousand(reg_user, crt_channel):
clear_v2()
message_string = "a" * 1001
user_token = reg_user(0)['token']
channel_id = crt_channel(user_token)['channel_id']
with pytest.raises(InputError):
message_send_v2(user_token, channel_id, message_string)
def test_message_edit_message_id_not_exist():
# InputError should be raised if message_id not found
clear_v1()
user = auth_register_v2('*****@*****.**', 'password542', 'Fred', 'Moe')
channel = channels_create_v2(user['token'], 'Title', True)
message_send_v2(user['token'], channel['channel_id'], 'yo')
with pytest.raises(InputError):
message_edit_v2(user['token'], 2, 'fake msg')
def standup_handler(author_token, channel_id, duration):
sleep(duration)
channel_standup = find_channel(channel_id)['standup']
channel_standup['is_active'] = False
bundled_message = ''
for msg in channel_standup['messages']:
bundled_message += f"{msg['author_handle']}: {msg['message']}\n"
message_send_v2(author_token, channel_id, bundled_message)
def test_message_react_invalid_msg_id():
# Invalid message id raises InputError
clear_v1()
user = auth_register_v2("*****@*****.**", "password", "bob", "williams")
channel = channels_create_v2(user['token'], 'channel example', True)
message_send_v2(user["token"], channel['channel_id'], 'helo world')
with pytest.raises(InputError):
message_react_v1(user['token'], "invalid message id", 1)
def test_assorted_notifications():
clear_v1()
user1 = auth_register_v2("*****@*****.**", "finalpassword", "Eric",
"Zheng")
user2 = auth_register_v2("*****@*****.**", "validpassword", "Josh",
"Hatton")
channel1 = channels_create_v2(user1['token'], 'Channel 1', True)
channel_invite_v2(user1['token'], channel1['channel_id'],
user2['auth_user_id'])
msg1str = "Welcome to the channel @joshhatton"
msg1 = message_send_v2(user1['token'], channel1['channel_id'], msg1str)
message_react_v1(user2['token'], msg1['message_id'], 1)
msg2str = "Thanks for having me @ericzheng"
msg2 = message_send_v2(user2['token'], channel1['channel_id'], msg2str)
message_react_v1(user1['token'], msg2['message_id'], 1)
assert notifications_get_v1(user1['token']) == {
'notifications': [{
'channel_id':
channel1['channel_id'],
'dm_id':
-1,
'notification_message':
f"joshhatton tagged you in Channel 1: {msg2str[0:20]}"
}, {
'channel_id':
channel1['channel_id'],
'dm_id':
-1,
'notification_message':
"joshhatton reacted to your message in Channel 1"
}]
}
assert notifications_get_v1(user2['token']) == {
'notifications': [
{
'channel_id':
channel1['channel_id'],
'dm_id':
-1,
'notification_message':
"ericzheng reacted to your message in Channel 1"
},
{
'channel_id':
channel1['channel_id'],
'dm_id':
-1,
'notification_message':
f"ericzheng tagged you in Channel 1: {msg1str[0:20]}"
},
{
'channel_id': channel1['channel_id'],
'dm_id': -1,
'notification_message': "ericzheng added you to Channel 1"
},
]
}
def test_multiple_errors():
clear_v1()
user_1 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a')
channel_1 = channels_create_v2(user_1['token'], 'Channel 1', True)
user_2 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a')
channel_2 = channels_create_v2(user_1['token'], 'Channel 2', True)
with pytest.raises(InputError):
message_send_v2(user_1['token'], channel_2['channel_id'], 'a' * 1001)
message_send_v2(user_2['token'], channel_1['channel_id'], 'b' * 1001)
def test_not_in_channel():
clear_v1()
user_1 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a')
channel_1 = channels_create_v2(user_1['token'], 'Channel 1', True)
user_2 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a')
channel_2 = channels_create_v2(user_1['token'], 'Channel 2', True)
with pytest.raises(AccessError):
message_send_v2(user_1['token'], channel_2['channel_id'], 'Hey!')
message_send_v2(user_2['token'], channel_1['channel_id'], 'Imposter')
def test_correct_standup_active(create_valid_user_data):
users = create_valid_user_data['users']
channels = create_valid_user_data['channels']
time_sleep = 3
for i in range(10):
message_send_v2(users[0]['token'], channels[0]['channel_id'],
f"First channel message {i}.")
###################channel 1 standup start######################
standup_start_v1(users[0]['token'], channels[0]['channel_id'], time_sleep)
#calculate the time when the function should finish
time_finish = (
datetime.datetime.now() +
datetime.timedelta(seconds=time_sleep)).strftime("%Y-%m-%d %H:%M:%S")
time_finish = time.strptime(time_finish, "%Y-%m-%d %H:%M:%S")
time_finish = time.mktime(time_finish)
assert standup_active_v1(users[0]['token'],
channels[0]['channel_id'])['is_active'] == True
assert standup_active_v1(
users[0]['token'],
channels[0]['channel_id'])['time_finish'] == time_finish
time.sleep(time_sleep + 1)
###################channel 1 standup finishes######################
assert standup_active_v1(users[0]['token'],
channels[0]['channel_id'])['is_active'] == False
assert standup_active_v1(users[0]['token'],
channels[0]['channel_id'])['time_finish'] == None
###################channel 2 standup start######################
standup_start_v1(users[1]['token'], channels[1]['channel_id'], time_sleep)
#calculate the time when the function should finish
time_finish = (
datetime.datetime.now() +
datetime.timedelta(seconds=time_sleep)).strftime("%Y-%m-%d %H:%M:%S")
time_finish = time.strptime(time_finish, "%Y-%m-%d %H:%M:%S")
time_finish = time.mktime(time_finish)
assert standup_active_v1(users[1]['token'],
channels[1]['channel_id'])['is_active'] == True
assert standup_active_v1(
users[1]['token'],
channels[1]['channel_id'])['time_finish'] == time_finish
time.sleep(time_sleep + 1)
###################channel 2 standup finishes######################
assert standup_active_v1(users[1]['token'],
channels[1]['channel_id'])['is_active'] == False
assert standup_active_v1(users[1]['token'],
channels[1]['channel_id'])['time_finish'] == None
clear_v1()
def test_message_send_user_not_in_channel():
# Test if AccessError is raised when user tries to leave a group
# that they are not a member of
clear_v1()
user_owner = auth_register_v2('*****@*****.**', 'password2321', 'Irwin', 'Dundee')
user = auth_register_v2('*****@*****.**', 'password2321232', 'Roland', 'Tiddle')
channel = channels_create_v2(user_owner['token'], 'Irwins Channel', True)
with pytest.raises(AccessError):
message_send_v2(user['token'], channel['channel_id'], 'can i join pls')
def test_message_remove_then_add(user_setup, channel_setup, dm_setup,
message_setup):
message_remove_v1(make_token(3), 0)
message_remove_v1(make_token(1), 1)
assert message_send_v2(make_token(2), 0, "hello") == {'message_id': 20}
assert message_send_v2(make_token(2), 0, "hello2") == {'message_id': 21}
message_remove_v1(make_token(1), 10)
assert message_senddm_v1(make_token(1), 1, "hello2") == {'message_id': 22}
def test_search_no_match(register_users):
assert search_v2(make_token(0), "Ciao") == {"messages": []}
channels_create_v2(make_token(0), "PublicChannel1", True)
dm_create_v1(make_token(0), [1, 2]) # dm_id 0
message_send_v2(make_token(0), 0, "Hello")
message_senddm_v1(make_token(0), 0, "Goodbye")
assert search_v2(make_token(0), "Ciao") == {"messages": []}
def test_edit_other_users_message():
clear_v1()
user_1 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a')
channel_1 = channels_create_v2(user_1['token'], 'Channel 1', True)
user_2 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a')
channel_invite_v2(user_1['token'], channel_1['channel_id'],
user_2['auth_user_id'])
msg1 = message_send_v2(user_1['token'], channel_1['channel_id'], 'Hey!')
msg2 = message_send_v2(user_2['token'], channel_1['channel_id'], 'Hello!')
with pytest.raises(AccessError):
message_edit_v2(user_1['token'], msg2['message_id'], 'He is stealing')
message_edit_v2(user_2['token'], msg1['message_id'],
'I did not say this')
def test_invalid_ch_message_id():
clear_v1()
user = auth_register_v2('*****@*****.**', 'passwod298372', 'Ming', 'Lee')
channel = channels_create_v2(user['token'], 'TITLE', True)
message_send_v2(user['token'], channel['channel_id'], 'test')
with pytest.raises(InputError):
message_share_v1(user["token"], "invalid", "message",
channel['channel_id'], -1)
message_share_v1(user["token"], 58181211, "message",
channel['channel_id'], -1)
message_share_v1(user["token"], "", "message", channel['channel_id'],
-1)
def test_message_edit_empty_msg_removed():
# If edited message is an empty string, remove the message
clear_v1()
user = auth_register_v2('*****@*****.**', 'pasword24323132', 'Reynold',
'Food')
channel = channels_create_v2(user['token'], 'Food channel', True)
message_send_v2(user['token'], channel['channel_id'],
'random message to dilute')
msg_sent = message_send_v2(user['token'], channel['channel_id'],
'tastes like poo')
message_edit_v2(user['token'], msg_sent['message_id'], '')
msg_list = channel_messages_v2(user['token'], channel['channel_id'], 0)
assert msg_list['messages'][0]["message"] == "random message to dilute"
def test_channel_pin(test_data):
a_data, b_data, c_data = test_data
a_ch_id = channels_create_v2(a_data["token"], "A channel",
True)["channel_id"]
b_ch_id = channels_create_v2(b_data["token"], "B channel",
True)["channel_id"]
channel_join_v2(c_data["token"], a_ch_id)
channel_join_v2(c_data["token"], b_ch_id)
# pin own message
a1_msg_id = message_send_v2(a_data["token"], a_ch_id,
"My own message")["message_id"]
message_pin_v1(a_data["token"], a1_msg_id)
messages = channel_messages_v2(a_data["token"], a_ch_id, 0)["messages"]
# we know there is only one message sent, so it must be index 0 of messages
assert messages[0]["message_id"] == a1_msg_id
assert messages[0]["is_pinned"] == True
# pin someone elses message
c1_msg_id = message_send_v2(c_data["token"], a_ch_id,
"C's message")["message_id"]
message_pin_v1(a_data["token"], c1_msg_id)
messages = channel_messages_v2(a_data["token"], a_ch_id, 0)["messages"]
# channel_messages is most recent message first
assert messages[0]["message_id"] == c1_msg_id
assert messages[0]["is_pinned"] == True
# b_ch
b1_msg_id = message_send_v2(b_data["token"], b_ch_id,
"B's message whoo")["message_id"]
message_pin_v1(b_data["token"], b1_msg_id)
messages = channel_messages_v2(b_data["token"], b_ch_id, 0)["messages"]
assert messages[0]["message_id"] == b1_msg_id
assert messages[0]["is_pinned"] == True
channel_addowner_v1(b_data["token"], b_ch_id, c_data["auth_user_id"])
c2_msg_id = message_send_v2(c_data["token"], b_ch_id,
"C's second message whoo")["message_id"]
message_pin_v1(c_data["token"], c2_msg_id)
messages = channel_messages_v2(c_data["token"], b_ch_id, 0)["messages"]
assert messages[0]["message_id"] == c2_msg_id
assert messages[0]["is_pinned"] == True
def test_correct_standup_short_message(create_valid_user_data):
users = create_valid_user_data['users']
channels = create_valid_user_data['channels']
time_sleep = 2
#generate some pre-exist messages in the channel
for i in range(10):
message_send_v2(users[0]['token'], channels[0]['channel_id'],
f"First channel message {i}.")
###################channel 1 strandup start######################
rt_val = standup_start_v1(users[0]['token'], channels[0]['channel_id'],
time_sleep)
#calculate the time when the function should finish
time_finish = (
datetime.datetime.now() +
datetime.timedelta(seconds=time_sleep)).strftime("%Y-%m-%d %H:%M:%S")
time_finish = time.strptime(time_finish, "%Y-%m-%d %H:%M:%S")
time_finish = time.mktime(time_finish)
#send some messages to the standup
standup_send_v1(users[0]['token'], channels[0]['channel_id'], "aaa")
standup_send_v1(users[0]['token'], channels[0]['channel_id'], "aaa")
standup_send_v1(users[0]['token'], channels[0]['channel_id'], "aaa")
standup_send_v1(users[0]['token'], channels[0]['channel_id'], "aaa")
standup_send_v1(users[1]['token'], channels[0]['channel_id'], "bbb")
standup_send_v1(users[2]['token'], channels[0]['channel_id'], "ccc")
#check the channel messages list so that the standup message has not been updated
msgs = channel_messages_v2(users[0]['token'], channels[0]['channel_id'], 0)
for i in range(10):
assert msgs['messages'][9 -
i]['message'] == f"First channel message {i}."
time.sleep(time_sleep + 1)
#####################channel 1 standup finishes##########################
#check the channel messages list so that the standup message has been updated
assert rt_val['time_finish'] == time_finish
msgs = channel_messages_v2(users[0]['token'], channels[0]['channel_id'], 0)
for i in range(10):
assert msgs['messages'][10 -
i]['message'] == f"First channel message {i}."
#the most recent message is standup
assert msgs['messages'][0][
'message'] == "ab: aaa\nab: aaa\nab: aaa\nab: aaa\ncd: bbb\nef: ccc"
def test_search_v2_find_apples_channel(reg_user):
clear_v2()
query_str = 'apples' #find messages that have the same text as this
user_register1 = reg_user(0)
channel_id = channels_create_v2(user_register1['token'], 'nice channel',
True)['channel_id']
message = 'i love bananas, dont like apples'
message_2 = 'i love bananas'
for _ in range(0, 20):
message_send_v2(user_register1['token'], channel_id, message_2)
message_send_v2(user_register1['token'], channel_id, message)
messages = search_v2(user_register1['token'], query_str)['messages']
for single_message in messages:
assert single_message['message'] != message_2
assert single_message['message'] == message
def test_share_message_not_in_receiving_channel():
clear_v1()
user_1 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a')
user_2 = auth_register_v2('*****@*****.**', 'bbbbbb', 'b', 'b')
channel_1 = channels_create_v2(user_1['token'], 'Channel 1', True)
channel_2 = channels_create_v2(user_2['token'], 'Channel 2', True)
msg1 = message_send_v2(user_1['token'], channel_1['channel_id'],
'Hi Chan 1')
msg2 = message_send_v2(user_2['token'], channel_2['channel_id'],
'Hi Chan 2')
with pytest.raises(AccessError):
message_share_v1(user_1['token'], msg2['message_id'], '', channel_2,
-1)
message_share_v1(user_2['token'], msg1['message_id'], 'SPAM!',
channel_1, -1)
def test_channel_messages_50_msgs():
# Test if channel_messsages correctly returns last 50 messages
clear_v1()
user = auth_register_v2("*****@*****.**", "password", "Tim", "Browning")
channel_example = channels_create_v2(user['token'], "Channel Example",
True)
for msgs in range(50):
message_send_v2(user['token'], channel_example['channel_id'],
"Test" + str(msgs))
channel_example_messages = channel_messages_v2(
user['token'], channel_example['channel_id'], 0)
# Since there are exactly 50 messages, end should return -1 as specified
assert len(channel_example_messages['messages']) == 50
assert channel_example_messages['start'] == 0
assert channel_example_messages['end'] == -1
