def test_edit_valid_owner(users):
"""
Testing if a single message can be sent, be stored and editted by owner
"""
user1, user2, chan = users
message_exp = 'Test 1 test 2 swiggity Swagg'
message_exp2 = 'This is to stop there being no message in the channel'
message.message_send(user1['token'], chan['channel_id'], message_exp2)
message_id = message.message_send(user2['token'], chan['channel_id'],
message_exp)
message_from_channel = channel.channel_messages(user1['token'],
chan['channel_id'], 0)
#Checks that the message was added
assert message_exp == message_from_channel['messages'][0]['message']
assert user2['u_id'] == message_from_channel['messages'][0]['u_id']
assert message_id['message_id'] == message_from_channel['messages'][0][
'message_id']
new_message = "This is the new message"
message.message_edit(user1['token'], message_id['message_id'], new_message)
new_message_from_channel = channel.channel_messages(
user1['token'], chan['channel_id'], 0)
#Checks that the message was changed
assert new_message == new_message_from_channel['messages'][0]['message']
assert user2['u_id'] == new_message_from_channel['messages'][0]['u_id']
assert message_id['message_id'] == new_message_from_channel['messages'][0][
'message_id']
other.clear()
def test_edit_no_message(users):
"""
Tests that a message edit with no message acts as a delete
"""
user1, user2, chan = users
message_exp = 'Test 1 test 2 swiggity Swagg'
message_exp2 = 'This is to stop there being no message in the channel'
message.message_send(user1['token'], chan['channel_id'], message_exp2)
message_id = message.message_send(user2['token'], chan['channel_id'],
message_exp)
message_from_channel = channel.channel_messages(user1['token'],
chan['channel_id'], 0)
#Checks that the message was added
assert message_exp == message_from_channel['messages'][0]['message']
assert user2['u_id'] == message_from_channel['messages'][0]['u_id']
assert message_id['message_id'] == message_from_channel['messages'][0][
'message_id']
#Uses the function message edit but has the message editted to an empty string
message.message_edit(user2['token'], message_id['message_id'], '')
new_message_from_channel = channel.channel_messages(
user1['token'], chan['channel_id'], 0)
#Checks that the message was removed
assert message_exp != new_message_from_channel['messages'][0]['message']
assert user2['u_id'] != new_message_from_channel['messages'][0]['u_id']
assert message_id['message_id'] != new_message_from_channel['messages'][0][
'message_id']
other.clear()
def test_standup_start_simple():
clear()
user1, user2 = register_n_users(2)
# Create channel and join
channel = channels_create(user1["token"], "channel1", is_public=True)
channel_join(user2["token"], channel["channel_id"])
# Start the standup period
standup = standup_start(user1["token"], channel["channel_id"], 1)
assert standup["time_finish"] == round(time() + 1)
# Send two standup message
standup_send(user1["token"], channel["channel_id"], "test1")
standup_send(user2["token"], channel["channel_id"], "test2")
# Assert the messages are empty
messages = channel_messages(user1["token"], channel["channel_id"],
0)["messages"]
assert len(messages) == 0
# Assert the two message has been sent when the standup period finishes
sleep(2)
messages = channel_messages(user1["token"], channel["channel_id"],
0)["messages"]
assert len(messages) == 1
user1_profile = user_profile(user1["token"], user1["u_id"])["user"]
user1_handle = user1_profile["handle_str"]
user2_handle = user_profile(user2["token"],
user2["u_id"])["user"]["handle_str"]
assert messages[0][
"message"] == f"{user1_handle}: test1\n{user2_handle}: test2"
assert messages[0]["u_id"] == user1_profile["u_id"]
def test_remove_valid_owner(users):
"""
Testing if a single message can be sent, be stored and removed by owner
"""
user1, user2, chan = users
message_exp2 = "Test this is different from message_exp"
message.message_send(user1["token"], chan['channel_id'], message_exp2)
message_exp = "Test 1 test 2 swiggity Swagg"
message_id = message.message_send(user2["token"], chan['channel_id'],
message_exp)
message_from_channel = channel.channel_messages(user1["token"],
chan['channel_id'], 0)
#Checks that the message was added
assert message_exp == message_from_channel["messages"][0]["message"]
assert user2["u_id"] == message_from_channel["messages"][0]["u_id"]
assert message_id["message_id"] == message_from_channel["messages"][0][
"message_id"]
message.message_remove(user1["token"], message_id["message_id"])
new_message_from_channel = channel.channel_messages(
user1["token"], chan['channel_id'], 0)
#Checks that the message was removed
assert message_exp != new_message_from_channel["messages"][0]["message"]
assert user2["u_id"] != new_message_from_channel["messages"][0]["u_id"]
assert message_id["message_id"] != new_message_from_channel["messages"][0][
"message_id"]
other.clear()
def test_message_react_data():
_, wenyao_dict, weiqiang_dict, channel1, channel2 = initialise_data()
# send 2 messages in different channel
message1 = message_send(wenyao_dict['token'], channel1['channel_id'],
"hello1")
message2 = message_send(weiqiang_dict['token'], channel2['channel_id'],
"hello2")
# react both messages
message_react(wenyao_dict['token'], message1['message_id'], 1)
message_react(weiqiang_dict['token'], message2['message_id'], 1)
messages_detail1 = channel_messages(wenyao_dict['token'],
channel1['channel_id'], 0)
messages_detail2 = channel_messages(weiqiang_dict['token'],
channel2['channel_id'], 0)
# check the information returned by channel_message
assert messages_detail1['messages'][0]['reacts'][0][
'is_this_user_reacted'] == True
assert messages_detail1['messages'][0]['reacts'][0]['u_ids'] == [
wenyao_dict['u_id']
]
assert messages_detail2['messages'][0]['reacts'][0][
'is_this_user_reacted'] == True
assert messages_detail2['messages'][0]['reacts'][0]['u_ids'] == [
weiqiang_dict['u_id']
]
def test_channel_messages_more_than_fifty(reset, create_public_channel):
'''
Testing sending more than 50 messages
and checking the function returns only the first 50 (pagination)
Unfortunately, we have to use a for loop
'''
# create a public channel using fixture and return its details and the
# owner's
channel_id, owner_info = create_public_channel
sent_msgs_ids = []
# for loop to send messages
# the first message of the channel was sent by hangman bot
for i in range(50):
sent_msgs_ids.append(
message_send(owner_info['token'], channel_id['channel_id'],
"message " + str(i)))
# retrieving message list
msgs = channel_messages(owner_info['token'], channel_id['channel_id'], 0)
# asserting start and end are correct
assert msgs['start'] == 0
assert msgs['end'] == 50
# changing the start message to 1
msgs = channel_messages(owner_info['token'], channel_id['channel_id'], 1)
# asserting start and end are correct
assert msgs['start'] == 1
assert msgs['end'] == -1
def test_react_succesfully():
clear()
user_a, user_b = register_n_users(2)
public_channel_id = channels_create(user_a["token"], "public_channel",
True)["channel_id"]
# user_b join the channel created by user_a
channel_join(user_b["token"], public_channel_id)
message_id = message_send(user_a["token"], public_channel_id,
"Nice to see you mate")["message_id"]
# user_a react to his own message
message_react(user_a["token"], message_id, 1)
# Message from the perspective of user_a
message_a = channel_messages(user_a["token"], public_channel_id,
0)["messages"][0]
# user_a reacted
assert message_a["reacts"][0]["is_this_user_reacted"] == True
assert user_a["u_id"] in message_a["reacts"][0]["u_ids"]
# Message from the perspective of user_b
message_b = channel_messages(user_b["token"], public_channel_id,
0)["messages"][0]
# user_b haven't reacted
assert message_b["reacts"][0]["is_this_user_reacted"] == False
# user_b react to the message
message_react(user_b["token"], message_id, 1)
message_b = channel_messages(user_b["token"], public_channel_id,
0)["messages"][0]
assert message_b["reacts"][0]["is_this_user_reacted"] == True
assert user_b["u_id"] in message_b["reacts"][0]["u_ids"]
def test_message_sendlater_more_channels():
_, wenyao_dict, _, channel_team1, _ = initialise_data()
channel_team2 = channels_create(wenyao_dict['token'], "team2", True)
time_sent = int(time.time())
time_sent += 3
message_sendlater(wenyao_dict['token'], channel_team1['channel_id'],
"hi there1", time_sent)
message_sendlater(wenyao_dict['token'], channel_team2['channel_id'],
"hi there2", time_sent)
# check the return value from messages details
messages_detail1 = channel_messages(wenyao_dict['token'],
channel_team1['channel_id'], 0)
messages_detail2 = channel_messages(wenyao_dict['token'],
channel_team2['channel_id'], 0)
assert len(messages_detail1['messages']) == 0
assert len(messages_detail2['messages']) == 0
# sleep for 5s
time.sleep(5)
messages_detail1 = channel_messages(wenyao_dict['token'],
channel_team1['channel_id'], 0)
messages_detail2 = channel_messages(wenyao_dict['token'],
channel_team2['channel_id'], 0)
assert len(messages_detail1['messages']) == 1
assert len(messages_detail2['messages']) == 1
assert messages_detail1['messages'][0]['message'] == "hi there1"
assert messages_detail2['messages'][0]['message'] == "hi there2"
def test_channel_messages_invalid_user(channel_init):
'''
test_channel_messages_invalid_user
'''
with pytest.raises(AccessError):
#Test with valid index and channel_id
channel_messages(channel_init[3]['token'], channel_init[2], 0)
def test_channel_messages_invalid_index(channel_init):
'''
test_channel_messages_invalid_index
'''
with pytest.raises(InputError):
#Test with valid user and channel_id
channel_messages(channel_init[0]['token'], channel_init[2], 1)
def test_channel_messages_invalid_channel(channel_init):
'''
test_channel_messages_invalid_channel
'''
with pytest.raises(InputError):
#Test with valid user and index
channel_messages(channel_init[0]['token'], "", 0)
def test_message_unpin_others_msg(make_users):
# setting up users and public channel
user_ab, user_cd = make_users
new_ch = channels_create(user_ab['token'], 'test_channel_public', True)
channel_invite(user_ab["token"], new_ch["channel_id"], user_cd["u_id"])
msg_id0 = message_send(
user_ab["token"], new_ch["channel_id"],
"This message by the owner will not be pinned.")["message_id"]
msg_id1 = message_send(
user_cd["token"], new_ch["channel_id"],
"This message from a normal member will be pinned by the owner"
)["message_id"]
message_pin(user_ab["token"], msg_id1)
msg_dict = channel_messages(user_ab["token"], new_ch["channel_id"],
0)["messages"]
assert msg_dict[0]["is_pinned"]
assert not msg_dict[1]["is_pinned"]
message_unpin(user_ab["token"], msg_id1)
assert not channel_messages(user_ab["token"], new_ch["channel_id"],
0)["messages"][0]["is_pinned"]
def test_channel_messages_except():
reset()
u_id, token = get_user("user1")
channel_id = channels.channels_create(token, "Example Channel",
True)['channel_id']
# InputError:
# Channel ID is not a valid channel
# Assumption that 0 is an invalid _id and testing type error
with pytest.raises(InputError) as e:
assert channel.channel_messages(token, 0, 0)
#with pytest.raises(InputError) as e:
# assert channel.channel_messages(token,"somestring",0)
# Start is greater than the total number of messages in the channel
# Assuming that the list "messages" contains all the messages in the channel
#total_messages = len(channel.channel_messages(token,channel_id,u_id)["messages"])
max_int = sys.maxsize
with pytest.raises(InputError) as e:
assert channel.channel_messages(token, channel_id, max_int)
# Access Error:
# Authorised user is not a member of channel with channel_id
# Create a new user, who is not a member of channel with channel_id
random_id, random_token = get_user("user2")
with pytest.raises(AccessError) as e:
assert channel.channel_messages(random_token, channel_id, 0)
def test_message_sendlater_with_other_messages():
'''
tests the message_sendlater functionality in a channel which
already have messages
'''
other.clear()
send_time = int(time.time()) + 5
owner = auth.auth_register("*****@*****.**", "password", "Homer",
"Simpson")
channels.channels_create(owner['token'], "channel_1", True)
channel_2 = channels.channels_create(owner['token'], "channel_1", True)
message.message_send(owner['token'], channel_2['channel_id'],
"test message")
new_message_id = message.message_sendlater(
owner['token'], channel_2['channel_id'],
'this is the first test message', send_time)
messages = channel.channel_messages(owner['token'],
channel_2['channel_id'], 0)
assert messages['messages'][0]['message'] == 'test message'
time.sleep(6)
later_message = channel.channel_messages(owner['token'],
channel_2['channel_id'], 0)
assert later_message['messages'][0] == {
'message_id': new_message_id,
'u_id': owner['u_id'],
'message': 'this is the first test message',
'time_created': send_time,
'reacts': [],
'is_pinned': False,
}
def test_sendlater_single():
clear()
# setup
user = register_n_users(1)
channel_id = channels_create(user["token"], "name",
is_public=True)["channel_id"]
# send message with delay
send_at = int(round(time.time() + 1 * DELAY_SCALE))
message_sendlater(user["token"], channel_id, "message", send_at)
# make sure there are now messages
messages = channel_messages(user["token"], channel_id, start=0)
assert int(round(time.time())) < send_at, ERR_TOO_SLOW
assert len(messages["messages"]) == 0
# wait for the message to be sent
time.sleep(2)
# check that the message is there
messages = channel_messages(user["token"], channel_id, start=0)
assert len(messages["messages"]) == 1
assert messages["messages"][0]["message"] == "message"
# if this fails, there has been a time difference of more than half a second
# time.time() is a float, and floats shouldn't be compared with ==
assert messages["messages"][0]["time_created"] - send_at <= 1
def test_standup_send_complex():
reset_data()
member1 = auth_register('*****@*****.**', 'helloworld', 'a', 'A')
member2 = auth_register('*****@*****.**', 'thisisfun', 'b', 'B')
member3 = auth_register('*****@*****.**', 'iamrobbie', 'c', 'C')
channel = channels_create(member1['token'], 'Hey Channel', True)
channel_id = channel['channel_id']
channel_join(member2['token'], channel_id)
channel_join(member3['token'], channel_id)
standup_start(member1['token'], channel_id, 1)
assert standup_send(member1['token'], channel_id, '1\nSTOP') == {}
assert standup_send(member2['token'], channel_id, '2\nSTOP') == {}
assert standup_send(member3['token'], channel_id, '3\nSTOP') == {}
sleep(1.1)
tmp = channel_messages(member1['token'], channel_id, 0)
message = tmp['messages'][0]
timestamp = message['time_created']
assert channel_messages(member1['token'], channel_id, 0) == {
'messages': [
{
'message_id': 1,
'u_id': 1,
'message': 'aa: 1\nSTOP\nbb: 2\nSTOP\ncc: 3\nSTOP',
'time_created': timestamp
},
],
'start': 0,
'end': -1,
}
def test_standup_start_complex():
reset_data()
member1 = auth_register('*****@*****.**', 'helloworld', 'ARoy', 'Wallace')
member2 = auth_register('*****@*****.**', 'helloworld', 'BRoy', 'Wallace')
test_channel = channels_create(member1['token'], 'New Channel', True)
channel_id = test_channel['channel_id']
channel_join(member2['token'], channel_id)
standup_start(member2['token'], channel_id, 1)
standup_send(member1['token'], channel_id, 'Standup message1')
standup_send(member2['token'], channel_id, 'Standup message2')
sleep(1.1)
tmp = channel_messages(member1['token'], channel_id, 0)
message = tmp['messages'][0]
timestamp = message['time_created']
assert channel_messages(member2['token'], channel_id, 0) == {
'messages': [
{
'message_id': 1,
'u_id': 2,
'message': 'aroywallace: Standup message1\nbroywallace: Standup message2',
'time_created': timestamp
},
],
'start': 0,
'end': -1,
}
def test_channel_messages_start_greater_than_end():
user_1 = auth_register("*****@*****.**", "12345678", "Devansh",
"Kala")
user_1_u_id = user_1["u_id"]
user_1_token = user_1["token"]
user_2 = auth_register("*****@*****.**", "9101112131414", "Jane",
"Smith")
user_2_u_id = user_2["u_id"]
user_2_token = user_2["token"]
new_channel = channels_create(user_1_token, "NEWCHANNEL", True)
new_channel_channel_id = new_channel["channel_id"]
#user_2 is added to the channel
channel_invite(user_1_token, new_channel_channel_id, user_2_u_id)
#user_1 is used to get the start and end of the messages
new_channel_channel_messages = channel_messages(user_1_token,
new_channel_channel_id, 0)
new_channel_message_start = new_channel_channel_messages["start"]
new_channel_message_end = new_channel_channel_messages["end"]
#user_2 cannot access messages which are greater than the start + end + 1000
with pytest.raises(InputError) as e:
channel_messages(
user_2_token, new_channel_channel_id,
new_channel_message_start + new_channel_message_end + 1000)
def test_search_multiple_channels():
user_info = auth.auth_register('m@gmail', 'sadsad', 'name', 'lastname')
# Creating the channel
channels.channels_create(user_info['token'], 'a', True)
channels.channels_create(user_info['token'], 'b', True)
# Messaging the channel
message.message_send(user_info['token'], 1, "hello there my name is John")
message.message_send(user_info['token'], 2, "hello there my name is John")
# Finding a timestamp
tmp = channel.channel_messages(user_info['token'], 1, 0)
message1 = tmp['messages'][0]
timestamp1 = message1['time_created']
tmp2 = channel.channel_messages(user_info['token'], 2, 0)
message2 = tmp2['messages'][0]
timestamp2 = message2['time_created']
# Giving all messages containing the query string
assert other.search(user_info['token'], "hello") == {
'messages': [{
'message_id': 1,
'u_id': 1,
'message': 'hello there my name is John',
'time_created': timestamp1,
}, {
'message_id': 2,
'u_id': 1,
'message': 'hello there my name is John',
'time_created': timestamp2,
}],
}
def test_timer_messages(users1):
"""
Testing The correct series of messages is printed in the channel
"""
user1, chan = users1
message_exp = "/KAHIO/Question/ A/ 6"
message_id = message.message_send(user1["token"], chan['channel_id'],
message_exp)
message_from_channel = channel.channel_messages(user1["token"],
chan['channel_id'], 0)
assert message_from_channel["messages"][0]["message"] == "Question"
assert user1["u_id"] == message_from_channel["messages"][0]["u_id"]
assert message_id["message_id"] == message_from_channel["messages"][0][
"message_id"]
time.sleep(0.4)
for i in range(0, 5):
message_from_channel = channel.channel_messages(
user1["token"], chan['channel_id'], 0)
assert message_from_channel["messages"][0][
"message"] == f"The kahoi game has {6-i} seconds remaining"
assert user1["u_id"] == message_from_channel["messages"][0]["u_id"]
time.sleep(1)
time.sleep(1)
message_from_channel = channel.channel_messages(user1["token"],
chan['channel_id'], 0)
message_exp = "Kahio game has ended.\nThe correct answer was a\nNo correct answers"
assert message_from_channel["messages"][0]["message"] == message_exp
assert user1["u_id"] == message_from_channel["messages"][0]["u_id"]
other.clear()
def test_send_answer_valid(users):
"""
Testing if a single message can be sent and be stored
"""
user1, user2, chan = users
message_exp = "/KAHIO/Question/ A/ 10"
message_id = message.message_send(user1["token"], chan['channel_id'],
message_exp)
message_from_channel = channel.channel_messages(user1["token"],
chan['channel_id'], 0)
assert message_from_channel["messages"][0]["message"] == "Question"
assert user1["u_id"] == message_from_channel["messages"][0]["u_id"]
assert message_id["message_id"] == message_from_channel["messages"][0][
"message_id"]
message_ans = " A"
message_id2 = message.message_send(user2["token"], chan['channel_id'],
message_ans)
time.sleep(11)
message_from_channel = channel.channel_messages(user1["token"],
chan['channel_id'], 0)
assert user1["u_id"] == message_from_channel["messages"][0]["u_id"]
occured = False
for cur_message in message_from_channel["messages"]:
if message_id2["message_id"] == cur_message["message_id"]:
assert cur_message["u_id"] == user1["u_id"]
assert cur_message[
"message"] == "KevinHuang guessed the correct answer"
occured = True
assert occured is True
other.clear()
def test_standup_send_handle():
"""
Tests if standup_start and standup_send works.
"""
clear()
user1 = auth.auth_register("*****@*****.**", "password", "Bilbo", "Baggins")
channel_dict = channels.channels_create(user1['token'], "test_channel", True)
user.user_profile_sethandle(user1['token'], 'handle')
standup.standup_start(user1['token'], channel_dict['channel_id'], 3)
standup.standup_send(user1['token'], channel_dict['channel_id'], "message1")
time.sleep(5)
standup.standup_active(user1['token'], channel_dict['channel_id'])
message_dict = channel.channel_messages(user1['token'], channel_dict['channel_id'], 0)
assert message_dict['messages'][0]['message'] == ("handle: message1")
user.user_profile_sethandle(user1['token'], 'eren')
standup.standup_start(user1['token'], channel_dict['channel_id'], 3)
standup.standup_send(user1['token'], channel_dict['channel_id'], "message1")
time.sleep(5)
standup.standup_active(user1['token'], channel_dict['channel_id'])
message_dict = channel.channel_messages(user1['token'], channel_dict['channel_id'], 0)
assert message_dict['messages'][0]['message'] == ("eren: message1")
def test_send_answer_incorrect(users):
"""
Testing if a single message can be sent and be stored
"""
user1, user2, chan = users
message_exp = "/KAHIO/Question/ A/ 1"
message_id = message.message_send(user1["token"], chan['channel_id'],
message_exp)
message_from_channel = channel.channel_messages(user1["token"],
chan['channel_id'], 0)
assert message_from_channel["messages"][0]["message"] == "Question"
assert user1["u_id"] == message_from_channel["messages"][0]["u_id"]
assert message_id["message_id"] == message_from_channel["messages"][0][
"message_id"]
message_ans = " b"
message_id2 = message.message_send(user2["token"], chan['channel_id'],
message_ans)
time.sleep(2)
message_from_channel = channel.channel_messages(user1["token"],
chan['channel_id'], 0)
message_exp = "Kahio game has ended.\nThe correct answer was a\nNo correct answers"
assert message_from_channel["messages"][0]["message"] == message_exp
assert user1["u_id"] == message_from_channel["messages"][0]["u_id"]
bling = True
for cur_message in message_from_channel["messages"]:
if message_id2["message_id"] == cur_message["message_id"]:
assert cur_message["u_id"] == user2["u_id"]
assert cur_message["message"] == " b"
bling = False
assert bling is False
other.clear()
def test_hangman():
''' Tests hangman game (just for coverage) '''
clear()
user = auth_register('*****@*****.**', 'password', 'Admin', 'User')
channel = channels_create(user['token'], 'Channel', True)
# Hangman game not started
message_send(user['token'], channel['channel_id'], '/guess A')
messages = channel_messages(user['token'], channel['channel_id'], 0)['messages']
assert len(messages) == 2
# Hangman game already started (doesn't raise Exception, just sends a message
# saying game already in progress, and displays the current game)
message_send(user['token'], channel['channel_id'], '/hangman start')
messages = channel_messages(user['token'], channel['channel_id'], 0)['messages']
assert len(messages) == 4
message_send(user['token'], channel['channel_id'], '/hangman start')
messages = channel_messages(user['token'], channel['channel_id'], 0)['messages']
assert len(messages) == 7
# Invalid message format
message_send(user['token'], channel['channel_id'], '/guess')
messages = channel_messages(user['token'], channel['channel_id'], 0)['messages']
assert len(messages) == 9
# Can't really test hangman guesses (esp win condition), so..
for _ in range(5):
message_send(user['token'], channel['channel_id'], '/guess z')
message_send(user['token'], channel['channel_id'], '/guess Z')
message_send(user['token'], channel['channel_id'], '/guess hellowolrd')
def test_bot_message_parser_prune():
''' Message prune tests '''
clear()
# Check messages have been deleted - and bot sends a temporary message (10s)
f_owner = auth_register('*****@*****.**', 'password', 'Admin', 'User')
channel = channels_create(f_owner['token'], 'Channel', True)
message_send(f_owner['token'], channel['channel_id'], 'Hello, World!')
# Invalid commands should just display error, not raise exceptions
message_send(f_owner['token'], channel['channel_id'], '/prune 5x')
# Flockr owner sends two messages, bot adds one
messages = channel_messages(f_owner['token'], channel['channel_id'], 0)['messages']
assert len(messages) == 3
# Invalid prune amount (4 maximum including /prune command message)
message_send(f_owner['token'], channel['channel_id'], '/prune 5')
# Bot displays error message
messages = channel_messages(f_owner['token'], channel['channel_id'], 0)['messages']
assert len(messages) == 5
# Successful prune
message_send(f_owner['token'], channel['channel_id'], '/prune 6')
messages = channel_messages(f_owner['token'], channel['channel_id'], 0)['messages']
assert len(messages) == 1
# Bot message should be automatically removed after 10 seconds
time.sleep(13)
messages = channel_messages(f_owner['token'], channel['channel_id'], 0)['messages']
assert len(messages) == 0
def test_message_prune_valid():
''' Valid test cases for message prune (function) '''
clear()
# Register users, create channel and users join
f_owner = auth_register('*****@*****.**', 'password', 'Admin', 'User')
c_owner = auth_register('*****@*****.**', 'password', 'Chantelle', 'Owner')
r_user = auth_register('*****@*****.**', 'password', 'Random', 'User')
channel = channels_create(c_owner['token'], 'Channel', True)
channel_join(r_user['token'], channel['channel_id'])
channel_join(f_owner['token'], channel['channel_id'])
# Send 3 dummy messages
message_send(f_owner['token'], channel['channel_id'], 'Message 1')
message_send(c_owner['token'], channel['channel_id'], 'Message 2')
message_send(r_user['token'], channel['channel_id'], 'Message 3')
messages = channel_messages(r_user['token'], channel['channel_id'], 0)['messages']
assert len(messages) == 3
# Valid pruning from Flockr owner
message_prune(f_owner['token'], channel['channel_id'], 3)
messages = channel_messages(r_user['token'], channel['channel_id'], 0)['messages']
assert len(messages) == 0
# Send 3 dummy messages
message_send(f_owner['token'], channel['channel_id'], 'Message 1')
message_send(c_owner['token'], channel['channel_id'], 'Message 2')
message_send(r_user['token'], channel['channel_id'], 'Message 3')
messages = channel_messages(r_user['token'], channel['channel_id'], 0)['messages']
assert len(messages) == 3
# Valid pruning from Channel owner
message_prune(c_owner['token'], channel['channel_id'], 3)
messages = channel_messages(c_owner['token'], channel['channel_id'], 0)['messages']
assert len(messages) == 0
def test_user_remove_messages_removed(
reset, create_public_channel, make_user_cd):
'''
Testing if the users messages are removed
'''
# creating a public channel
channel_id, owner_info = create_public_channel
# creating user
user_info = make_user_cd
# joining and sending a message
channel_join(user_info['token'], channel_id['channel_id'])
message_send(user_info['token'], channel_id['channel_id'], 'HelloWorld')
print(
channel_messages(
owner_info['token'],
channel_id['channel_id'],
start=0))
# removing user
user_remove(owner_info['token'], user_info['u_id'])
# should be empty
messages = channel_messages(
owner_info['token'],
channel_id['channel_id'],
start=0)
assert len(messages['messages']) == 1
def test_invalid_channel_id_messages():
'''test for invalid channel id'''
reset_data()
owner = auth_register("*****@*****.**", "avengers", "Natasha",
"Romanova")
with pytest.raises(InputError):
channel.channel_messages(owner['token'], 8333, 0)
def test_channel_messages_invalid_start():
"""Tests passing an invalid start into channel_messages """
clear()
new_user = auth_register("*****@*****.**", "maccas19201", "Travis",
"Scott")
new_channel = channels_create(new_user["token"], "Halloween Sesh", False)
with pytest.raises(InputError):
channel_messages(new_user["token"], new_channel["channel_id"], -1)
def test_access_error(initial_users, initial_msg):
# access error when Authorised user is not
# a member of channel with channel_id
with pytest.raises(AccessError):
assert channel.channel_messages(users[2]['token'], channels[0]['channel_id'], 0)
# access error when given token does not refer to a valid user
with pytest.raises(AccessError):
assert channel.channel_messages('invalid_token', channels[0]['channel_id'], 0)
