def test_message_send_not_in_channel():
'''
Testing requesting to send message when not in channel
'''
k_token = register('*****@*****.**', 'kenis123', 'Ken', 'Li')[1]
with pytest.raises(HTTPError):
message_send(k_token, 1, 'Bad message')
logout(k_token)
def test_message_send_invalid_token():
'''
Testing requesting with invalid token
'''
a_token = login('*****@*****.**', 'pass123456')[1]
with pytest.raises(HTTPError):
message_send(a_token + 'x', 1, 'Hello world')
logout(a_token)
def test_message_send_invalid_message():
'''
Testing sending an invalid message
'''
a_token = login('*****@*****.**', 'pass123456')[1]
with pytest.raises(HTTPError):
message_send(a_token, 1, 'a' * 1001)
logout(a_token)
def test_message_edit_delete_empty(reset):
j_token = register("*****@*****.**", "1234566", "Josh", "Wang")[1]
ch_id = channels_create(j_token, "new_channel", True)
message_send(j_token, ch_id,
"This is the first message before any editing.")
msg_id2 = message_send(j_token, ch_id, "This is another message")
message_edit(j_token, msg_id2, "")
assert len(search(j_token, "message")["messages"]) == 1
def test_search_invalid_token(reset):
'''
Invalid request with invalid token
'''
j_token = register("*****@*****.**",
"paris in the rain", "Josh", "Wang")[1]
ch_id = channels_create(j_token, "new_channel", True)
message_send(j_token, ch_id, "First message")
with pytest.raises(HTTPError):
search(j_token + 'x', 'First')
def test_search_empty(reset):
'''
Searching for an empty string
'''
j_token = register("*****@*****.**",
"paris in the rain", "Josh", "Wang")[1]
ch_id = channels_create(j_token, "new_channel", True)
message_send(j_token, ch_id, "First message")
message_send(j_token, ch_id, "Second message")
assert len(search(j_token, "")["messages"]) == 0
def test_message_send_ok(reset):
'''
Testing sending a valid message by an authorised user
'''
a_token = register('*****@*****.**', 'pass123456', 'Alan', 'Brown')[1]
channel_id = channels_create(a_token, 'test_public', True)
message_send(a_token, channel_id, 'test message')
msg_list = channel_messages(a_token, channel_id, 0)[0]
assert len(msg_list) == 2 # hangman bot sends a message as well
assert msg_list[0]['message'] == 'test message'
logout(a_token)
def test_search_query_str_too_long(reset):
'''
Invalid request with a long query string
'''
j_token = register("*****@*****.**",
"paris in the rain", "Josh", "Wang")[1]
ch_id = channels_create(j_token, "new_channel", True)
message_send(j_token, ch_id, "First message")
message_send(j_token, ch_id, "Second message")
with pytest.raises(HTTPError):
search(j_token, "i" * 1001)
def test_message_remove_own(reset):
'''
Testing removing a valid message by a valid authorised user
'''
a_token = register('*****@*****.**', 'pass123456', 'Alan', 'Brown')[1]
channel_id = channels_create(a_token, 'test_public', True)
msg0_id = message_send(a_token, channel_id, 'test message to be removed')
# check list is now empty after removal
message_remove(a_token, msg0_id)
message_send(a_token, channel_id, 'new_test_message')
msg_list = channel_messages(a_token, channel_id, 0)[0]
assert len(msg_list) == 2 # hangman bot sends a message as well..
assert msg_list[0]['message'] == 'new_test_message'
logout(a_token)
def test_message_edit(reset):
j_token = register("*****@*****.**", "1234566", "Josh", "Wang")[1]
ch_id = channels_create(j_token, "new_channel", True)
msg_id1 = message_send(j_token, ch_id,
"This is the first message before any editing.")
msg_id2 = message_send(j_token, ch_id, "This is another message")
assert len(search(j_token, "message")["messages"]) == 2
message_edit(j_token, msg_id1, "Hurricane")
assert len(search(j_token, "message")["messages"]) == 1
assert search(j_token, "message")["messages"][0]["message_id"] == msg_id2
assert len(search(j_token, "Hurr")["messages"]) == 1
assert search(j_token, "Hurr")["messages"][0]["message_id"] == msg_id1
def test_message_sendlater_threading(reset):
'''
Testing other requests can be processed concurrently without disturbing sendlater
'''
k_token = register('*****@*****.**', 'kenis123', 'Ken', 'Li')[1]
channel_id = channels_create(k_token, 'test_public', True)
message_sendlater(k_token, channel_id, 'sending later', time.time() + 1)
message_send(k_token, channel_id, 'test message0')
message_send(k_token, channel_id, 'test message1')
time.sleep(2)
msg_list = channel_messages(k_token, channel_id, 0)[0]
assert len(msg_list) == 4 # hangman sends a message as well
assert msg_list[0]['message'] == 'sending later'
logout(k_token)
def test_search_data_missing(reset):
'''
Missing query string in request
'''
j_token = register("*****@*****.**",
"paris in the rain", "Josh", "Wang")[1]
ch_id = channels_create(j_token, "new_channel", True)
message_send(j_token, ch_id, "First message")
data = urllib.parse.urlencode({
'token': j_token
})
with pytest.raises(HTTPError):
urllib.request.urlopen(f"{urls.SEARCH_URL}?{data}")
def test_message_react_invalid_react():
a_token = login('*****@*****.**', 'pass123456')[1]
msg1_id = message_send(a_token, 1, 'a second test message')
with pytest.raises(HTTPError):
message_react(a_token, msg1_id, 2)
logout(a_token)
def test_message_unreact_no_existing_react(reset):
a_token = register('*****@*****.**', 'pass123456', 'Admin', 'Heeblo')[1]
channels_create(a_token, 'test_public', True)
msg0_id = message_send(a_token, 1, 'I am new here.')
with pytest.raises(HTTPError):
message_unreact(a_token, msg0_id, 1)
logout(a_token)
def test_message_pin_not_owner_tries():
c_token = register('*****@*****.**', 'ssap12652', 'Chen', 'Bee')[1]
channel_join(c_token, 1)
msg1_id = message_send(c_token, 1, 'My own message')
with pytest.raises(HTTPError):
message_pin(c_token, msg1_id)
logout(c_token)
def test_message_unpin_not_pinned(reset):
a_token = register('*****@*****.**', 'pass123456', 'Admin', 'Heeblo')[1]
channel_id = channels_create(a_token, 'test_public', True)
msg0_id = message_send(a_token, channel_id, 'Not pinned message')
with pytest.raises(HTTPError):
message_unpin(a_token, msg0_id)
logout(a_token)
def test_message_unreact_not_in_channel():
c_token = register('*****@*****.**', 'ssap12652', 'Chen', 'Bee')[1]
channel_join(c_token, 1)
msg1_id = message_send(c_token, 1, 'I am new here.')
message_react(c_token, msg1_id, 1)
channel_leave(c_token, 1)
with pytest.raises(HTTPError):
message_unreact(c_token, 1, 1)
logout(c_token)
def test_message_react_already_reacted():
a_token = login('*****@*****.**', 'pass123456')[1]
channel_id_priv = channels_create(a_token, 'test_private', False)
msg1_id = message_send(a_token, channel_id_priv,
'test message please react')
message_react(a_token, msg1_id, 1)
with pytest.raises(HTTPError):
message_react(a_token, msg1_id, 1)
logout(a_token)
def test_message_unreact_own(reset):
a_token = register('*****@*****.**', 'pass123456', 'Alan', 'Brown')[1]
channel_id = channels_create(a_token, 'test_public', True)
msg0_id = message_send(a_token, channel_id, 'test message please react')
message_react(a_token, msg0_id, 1)
# unreacting
message_unreact(a_token, msg0_id, 1)
msg_list = channel_messages(a_token, channel_id, 0)[0]
assert msg_list[0]['reacts'][0]['u_ids'] == []
logout(a_token)
def test_message_remove_slackr_owner(reset):
# slackr owner
a_token = register('*****@*****.**', 'pass123456', 'Alan', 'Brown')[1]
k_token = register('*****@*****.**', 'kenis123', 'Ken', 'Li')[1]
# ken creates a channel
channel_id = channels_create(k_token, 'test_public', True)
msg0_id = message_send(k_token, channel_id, 'test message in ken channel')
message_send(k_token, channel_id, 'test message2 in ken channel')
message_remove(a_token, msg0_id)
msg_list = channel_messages(k_token, channel_id, 0)[0]
assert len(msg_list) == 2 # hangman bot sends a message at the start
assert msg_list[0]['message'] == 'test message2 in ken channel'
# unremoved message (2nd one sent) retains its ID
# hangman bot sends the first msg with id 1
assert msg_list[0]['message_id'] == 3
logout(a_token)
logout(k_token)
def test_message_remove_twice(reset):
a_token = register('*****@*****.**', 'pass123456', 'Alan', 'Brown')[1]
channel_id = channels_create(a_token, 'test_public', True)
msg0_id = message_send(a_token, channel_id, 'test message to be removed')
message_remove(a_token, msg0_id)
with pytest.raises(HTTPError):
message_remove(a_token, 0)
logout(a_token)
def test_message_pin_owner(reset):
a_token = register('*****@*****.**', 'pass123456', 'Admin', 'Heeblo')[1]
channel_id = channels_create(a_token, 'test_public', True)
msg0_id = message_send(a_token, channel_id, 'Pin this message')
# pins the message
message_pin(a_token, msg0_id)
msg_list = channel_messages(a_token, channel_id, 0)[0]
assert msg_list[0]['is_pinned']
logout(a_token)
def test_message_unpin_invalid_message(reset):
a_token = register('*****@*****.**', 'pass123456', 'Admin', 'Heeblo')[1]
channel_id = channels_create(a_token, 'test_public', True)
msg0_id = message_send(a_token, channel_id, 'Pin this message')
# pins the message
message_pin(a_token, msg0_id)
with pytest.raises(HTTPError):
message_unpin(a_token, msg0_id + 1)
logout(a_token)
def test_user_remove_removed_message(reset):
'''
A removed user has all the messages he has sent removed
'''
_, admin_token = register(
'*****@*****.**', 'HelloWorld', 'Yousif', 'Wang')
u_id, u_token = register('*****@*****.**', 'HelloWorld123', 'Josh', 'Wang')
# admin creates a channel
channel_id = channels_create(admin_token, 'Da channel', is_public=True)
# joining..
channel_join(u_token, channel_id)
# send a message
message_send(u_token, channel_id, 'HelloWorld')
# new user is removed
user_remove(admin_token, u_id)
# their message should be removed from the channel
messages, _, _ = channel_messages(admin_token, channel_id, start=0)
# the reason we assert 1 is because the hangman sends a message at the
# start of channel
assert len(messages) == 1
def test_standup_send_non_blocking(reset):
'''
Testing tinkering with standups does not block other things
'''
my_token = register('*****@*****.**',
'1231FFF!', 'Yousif', 'Khalid')[1]
# creating a channel
channel_id = channels_create(my_token, 'Yousifs Channel', is_public=True)
# starting a standup by me
standup_start(my_token, channel_id, length=3)
# message sent by me
standup_send(my_token, channel_id, 'should be last message sent pt1')
standup_send(my_token, channel_id, 'should be last message sent pt2')
message_send(my_token, channel_id, 'should be first message sent')
time.sleep(3.1)
messages = channel_messages(my_token, channel_id, start=0)[0]
# hangman bot sends a message at the creation of the channel
assert len(messages) == 3
assert messages[0]['message'] == \
'should be last message sent pt1\nshould be last message sent pt2'
def test_message_pin_owner_pins_user():
a_token = login('*****@*****.**', 'pass123456')[1]
k_token = register('*****@*****.**', 'kenis123', 'Ken', 'Li')[1]
channel_join(k_token, 1)
msg1_id = message_send(k_token, 1, 'User message')
# user a pins user k's message
message_pin(a_token, msg1_id)
msg_list = channel_messages(a_token, 1, 0)[0]
assert msg_list[0]['is_pinned'] and msg_list[1]['is_pinned']
logout(a_token)
logout(k_token)
def test_message_unpin_not_channel_owner(reset):
a_token = register('*****@*****.**', 'pass123456', 'Admin', 'Heeblo')[1]
channel_id = channels_create(a_token, 'test_public', True)
msg0_id = message_send(a_token, channel_id, 'Pin this message')
# pins the message
message_pin(a_token, msg0_id)
# make another user who is part of channel but not owner nor slackr owner
u_token = register('*****@*****.**', 'usersweakpw', 'Bob', 'Builder')[1]
channel_join(u_token, channel_id)
with pytest.raises(HTTPError):
message_unpin(u_token, msg0_id)
logout(a_token)
def test_message_unpin_slackr_owner_not_in_channel(reset):
a_token = register('*****@*****.**', 'pass123456', 'Admin', 'Heeblo')[1]
k_token = register('*****@*****.**', 'kenis123', 'Ken', 'Li')[1]
# ken creates a channel
k_channel_id = channels_create(k_token, 'test_public', True)
msg0_id = message_send(k_token, k_channel_id,
'Kens message in his channel')
message_pin(k_token, msg0_id)
# admin unpins the message sent by ken
message_unpin(a_token, msg0_id)
msg_list = channel_messages(k_token, k_channel_id, 0)[0]
assert not msg_list[0]['is_pinned']
logout(a_token)
logout(k_token)
def test_message_edit_reject_permission(reset):
j_token = register("*****@*****.**", "1234566", "Josh", "Wang")[1]
k_token = register("*****@*****.**", "jludagsfhjkliopasdf", "Ken", "Li")[1]
i_token = register("*****@*****.**", "aslkdfjwe", "Ian", "Jacobs")[1]
l_token = register("*****@*****.**", "ajsoqefdas", "Lloyd", "Freeman")[1]
ch_id = channels_create(k_token, "new_channel", True)
channel_join(i_token, ch_id)
channel_join(l_token, ch_id)
msg_id = message_send(l_token, ch_id, "This is a message")
message_edit(j_token, msg_id, "Josh is a slack owner and can edit")
message_edit(k_token, msg_id, "Ken is a channel owner and can edit")
message_edit(l_token, msg_id, "Lloyd wrote the message and cand edit")
with pytest.raises(HTTPError):
message_edit(i_token, msg_id,
"Ian was not involved and cannot edit for once")
def test_search_1(reset):
'''
can search a variety of strings sent by different users
in a multitude of channels of which the auth user is part
'''
j_token = register("*****@*****.**",
"paris in the rain", "Josh", "Wang")[1]
k_token = register("*****@*****.**", "pianoforte", "Ken", "Li")[1]
i_token = register("*****@*****.**",
"ilovetrimesters", "Ian", "Jacobs")[1]
ch_id1 = channels_create(j_token, "channel1", True)
ch_id2 = channels_create(k_token, "channel2", True)
ch_id3 = channels_create(i_token, "channel3", True)
channel_join(j_token, ch_id2)
channel_join(k_token, ch_id3)
message_send(j_token, ch_id1, "Cat get down!")
message_send(k_token, ch_id2, "this is the category")
message_send(i_token, ch_id3, "cataracts are bad for your eyes")
message_send(j_token, ch_id2, "scathe hat bat shat in the lsadfkl")
message_send(j_token, ch_id2, "token")
message_send(k_token, ch_id3, "a;sdkjf;lasdjf;lj 3wioru cate")
assert len(search(j_token, "cat")["messages"]) == 2
assert len(search(k_token, "cat")["messages"]) == 4
assert len(search(i_token, "cat")["messages"]) == 2
