def test_send_way_later():
user1 = auth.auth_register("*****@*****.**", "reddington", "James",
"Spader")
chan1 = channels.channels_create(user1['token'], "Zooper Dooper", False)
time1 = time_from_now(602)
time2 = time_from_now(6020)
mess1 = message.message_sendlater(user1['token'], chan1['channel_id'],
"ahoy", time1)
mess2 = message.message_sendlater(user1['token'], chan1['channel_id'],
"yoha", time2)
assert mess1['message_id'] == 1
assert mess2['message_id'] == 2
other.clear()
def test_standup_send_user_not_member():
"""Tests an non-member of a channel trying to participate in a standup in that channel"""
clear()
valid_user = auth_register("*****@*****.**", "validPassword",
"Validate", "Me")
new_channel = channels_create(valid_user["token"], "new_channel", False)
valid_user2 = auth_register("*****@*****.**", "validPassword2",
"Validate2", "Me2")
standup_start(valid_user["token"], new_channel["channel_id"], 3)
with pytest.raises(AccessError):
standup_send(valid_user2["token"], new_channel["channel_id"],
"stand the f*** up!")
time.sleep(3)
def test_auth_edit():
c_owner = auth_register("*****@*****.**","1234yu!","Hailey","Jung")
c_token = c_owner['token']
channel = channels_create(c_token,"test",True)
cid = channel['channel_id']
writer = auth_register("hkhkhk999@gmail","1asdfu!","Eunseo","Jung")
w_token = writer['token']
message = message_send(w_token,cid,"Hellooo")
mid = message['message_id']
no_body = auth_register("noone@gmail","1aasdffu!","Aww","Jung")
n_token = no_body['token']
with pytest.raises(AccessError):
message_edit(n_token, mid, "Iamtryingtofix")
def test_standup_start_after_allowed_again():
'''
Test that after the first standup is over, another can start
without errors
'''
clear()
user = auth_register("*****@*****.**", "password", "Firstname", "Lastname")
channel = channels_create(user['token'], "Channel", True)
standup_start(user['token'], channel['channel_id'], 1)
time.sleep(2)
standup_start(user['token'], channel['channel_id'], 1)
time.sleep(2)
def test_channels_listall():
"""
Testing successful uses of channels_listall without any errors
"""
user = auth.auth_register("*****@*****.**", "passwordabc", "first_name",
"last_name")
new_channel = channels.channels_create(user["token"], "my_channel", True)
list_result = channels.channels_listall(user["token"])["channels"]
assert list_result[0]["channel_id"] == 1
assert list_result[0]["name"] == "my_channel"
user2 = auth.auth_register("*****@*****.**", "passwordxyz", "first_name",
"last_name")
channel.channel_join(user2["token"], new_channel["channel_id"])
channels.channels_create(user2["token"], "our_channel", True)
list_result2 = channels.channels_listall(user2["token"])["channels"]
assert list_result2[0]["channel_id"] == 1
assert list_result2[0]["name"] == "my_channel"
assert list_result2[1]["channel_id"] == 2
assert list_result2[1]["name"] == "our_channel"
other.clear()
def test_channels_listall():
_, _, _, yixuan_dict, yuhan_dict = initialise_data()
# get the previous channels for yuhan
yuhan_prev_channels = channels_listall(yuhan_dict['token'])
# creat 2 channels including different members
team_lemon = channels_create(yixuan_dict['token'], "teamLemon", False)
team_lemon_id = team_lemon['channel_id']
team_pears = channels_create(yuhan_dict['token'], "teamPears", False)
team_pears_id = team_pears['channel_id']
# append the new added channels to the previous channels list
team_lemon_dict = {'channel_id': team_lemon_id, 'name': 'teamLemon'}
team_pears_dict = {'channel_id': team_pears_id, 'name': 'teamPears'}
yuhan_prev_channels['channels'].append(team_lemon_dict)
yuhan_prev_channels['channels'].append(team_pears_dict)
# get the current channel list
yuhan_curr_channels = channels_listall(yuhan_dict['token'])
# check if the list is same
assert yuhan_prev_channels == yuhan_curr_channels
def test_active_standupactive_token():
'''
If standup token is invalid
'''
clear()
user = auth.auth_register("*****@*****.**", "password", "First", "Last")
channel = channels.channels_create(user['token'], "name", True)
standup.standup_start(user['token'], channel["channel_id"], 2)
with pytest.raises(error.AccessError):
standup.standup_active('token', channel["channel_id"])
time.sleep(3)
def test_message_react_invalid_msg_id():
clear()
test_user0 = create_one_test_user()
# test_user0 creates 1 public channel
channel_id = channels_create(test_user0['token'], "Public Channel", True)
# test_user0 sends 1 message to public channel
message0 = "inital message"
message_send(test_user0['token'], channel_id['channel_id'], message0)
with pytest.raises(InputError):
assert message_react(test_user0['token'], 2, 1)
def test_message_react():
clear()
test_user0 = create_one_test_user()
# test_user0 creates 1 public channel
channel_id = channels_create(test_user0['token'], "Public Channel", True)
# test_user0 sends 1 message to public channel
message0 = "inital message"
message0_id = message_send(test_user0['token'], channel_id['channel_id'], message0)
message_react(test_user0['token'], message0_id['message_id'], 1) == {}
def test_channels_list():
#dictionary of token and uid when user logs in and the element removes when he logs out
helper_functions.clear_data()
user1_email = '*****@*****.**'
user1_password = '******'
user1_firstname = 'USER'
user1_lastname = '1'
diction = auth.auth_register(user1_email, user1_password, user1_firstname,
user1_lastname)
token = diction.get('token')
id_dict = channels.channels_create(token, user1_firstname, True)
channel_id = id_dict.get('channel_id')
channels.channels_create(token, user1_firstname, True)
chan = channels.channels_list(token)
chan = chan.get('channels')
assert channel_id != None
assert chan != None
assert True
def test_unreact_invalid_message_id_out_channel():
"""
Test a situation where a user trying to unreact to a message
but not in that channel
"""
clear()
user_a, user_b = register_n_users(2)
# user_a create a channel
channels_create(user_a["token"], "public_channel_a", True)["channel_id"]
# user_b create a channel and send message in his own channel
public_channel_id_b = channels_create(user_b["token"], "public_channel_b",
True)["channel_id"]
message_id_b = message_send(user_b["token"], public_channel_id_b,
"I am in channel_b")["message_id"]
# user_a join the channel and react to the user_b
channel_join(user_a["token"], public_channel_id_b)
message_react(user_a["token"], message_id_b, 1)
# user_a leave the channel
channel_leave(user_a["token"], public_channel_id_b)
# user_a should not be able to react the the message in the public_channel_b
with pytest.raises(InputError):
message_unreact(user_a["token"], message_id_b, 1)
def test_channels_create_success():
reset_data()
user_info = auth_register('*****@*****.**', 'sadsad', 'name', 'lastname')
assert channels_create(user_info['token'], 'a' * 20, True) == {
'channel_id': 1
}
assert channels_list(user_info['token']) == {
'channels': [{
'channel_id': 1,
'name': 'a' * 20
}]
}
def test_channels_create_simple():
reset_data()
user_info = auth_register('*****@*****.**', 'sadsad', 'name', 'lastname')
# Creating the channel
assert channels_create(user_info['token'], 'a', True) == {
'channel_id': 1,
}
assert channels_list(user_info['token']) == {
'channels': [{
'channel_id': 1,
'name': 'a'
}],
}
def test_message_react_valid_react(make_users):
# setting up users and public channel
user_ab, user_cd = make_users
new_public_channel = channels_create(user_ab['token'],
'test_channel_public', True)
# user_cd creates a private channel
new_private_channel = channels_create(user_cd['token'], 'private_channel',
False)
msg1 = message_send(user_ab['token'], new_public_channel['channel_id'],
"Hello world!")
msg2 = message_send(user_cd['token'], new_private_channel['channel_id'],
"Private msg")
# user_cd adds user_ab to their private channel
channel_invite(user_cd['token'], new_private_channel['channel_id'],
user_ab['u_id'])
# user_ab now reacts to both messages (1 in public, 1 in private channel)
message_react(user_ab['token'], msg1['message_id'], 1)
message_react(user_ab['token'], msg2['message_id'], 1)
# grab the list of messages in both channels
messages_public = channel_messages(user_ab['token'],
new_public_channel['channel_id'],
0)['messages']
messages_private = channel_messages(user_ab['token'],
new_private_channel['channel_id'],
0)['messages']
# check the reacts are there
assert messages_public[0]['reacts'] == [{
'react_id': 1,
'u_ids': [user_ab['u_id']],
'is_this_user_reacted': True,
}]
assert messages_private[0]['reacts'] == [{
'react_id': 1,
'u_ids': [user_ab['u_id']],
'is_this_user_reacted': True,
}]
def test_unauthorised_message_edit():
clear()
info = auth.auth_register("*****@*****.**", "ihfeh3hgi00d", "Bill",
"Gates")
channel_id = channels.channels_create(info['token'], 'validchannelname',
True)
firstmessage = message.message_send(info['token'],
channel_id['channel_id'], 'hello')
secondinfo = auth.auth_register("*****@*****.**", "ttteh3hgi00d",
"Billy", "Gale")
with pytest.raises(AccessError):
assert message.message_edit(secondinfo['token'],
firstmessage['message_id'], 'changing')
def test_channel_join():
reset()
u_id, token = get_user("user1")
channel_id = channels.channels_create(token, "Example Channel",
True)['channel_id']
# Function channel_join(token, channel_id)
# Returns {}
# Given a channel_id of a channel that the authorised user can join, adds them to that channel
# Join a channel that the user is not already a member of
# Create new user
new_id, new_token = get_user("user2")
assert channel.channel_join(new_token, channel_id) == {}
def test_message_send2():
clear()
info = auth.auth_register("*****@*****.**", "ihfeh3hgi00d", "Bill",
"Gates")
channel_id = channels.channels_create(info['token'], 'validchannelname',
True)
i = 0
while i < 51:
message.message_send(info['token'], channel_id['channel_id'], 'hello')
i += 1
print(channel.channel_messages(info['token'], channel_id['channel_id'], 0))
assert len(channel.channel_messages(info['token'], channel_id['channel_id'], 0)['messages']) \
== 50
def test_remove_continuous_send():
clear()
user = register_n_users(1)
channel_id = channels_create(user["token"], "channela",
is_public=True)["channel_id"]
for i in range(1, 50):
message = message_send(user["token"], channel_id, "message " + str(i))
message_remove(user["token"], message["message_id"])
assert channel_messages(user["token"], channel_id, 0)["end"] == -1
assert bool(channel_messages(user["token"], channel_id,
0)["messages"]) == False
def test_standupsend_tokenwrong():
'''
Invalid token
'''
clear()
user = auth.auth_register("*****@*****.**", "password", "First", "Last")
channel = channels.channels_create(user['token'], "name", True)
standup.standup_start(user['token'], channel["channel_id"], 1)
with pytest.raises(error.AccessError):
standup.standup_send('invalid', channel['channel_id'], 'RM')
time.sleep(2)
def test_edit_invalid_user_token():
clear()
user = register_n_users(1)
# Create a new channel
channel = channels_create(user["token"], "channel01", is_public=True)
# User sends a message
message = message_send(user["token"], channel["channel_id"],
"test message")
# Non-existent user tries to edit the message
with pytest.raises(AccessError):
assert message_edit(INVALID_USER_TOKEN, message["message_id"],
"edited message")
def test_messageunreact_invalid_input():
'''
Testing if errors returned when given invalid input
'''
clear()
# Registering users, creating channels and sending messages to both
user1 = auth_register("*****@*****.**", "user1pass", "user1", "last1",
None)
user2 = auth_register("*****@*****.**", "user2pass", "user2", "last2",
None)
token1 = user1['token']
token2 = user2['token']
ch_id1 = channels_create(token1, "aGreatChannel", True)['channel_id']
ch_id2 = channels_create(token2, "ChannelTwo", True)['channel_id']
m_id1 = message_send(token1, ch_id1, 'hey')['message_id']
m_id2 = message_send(token2, ch_id2, 'hello')['message_id']
message_react(token1, m_id1, 1)
# Trying to remove react from a non_existing message
with pytest.raises(InputError):
message_unreact(token1, m_id1 + 100, 1)
# Trying to unreact from a non_existing react type
with pytest.raises(InputError):
message_unreact(token1, m_id1, 1000)
# Trying to unreact to a message in a channel user has not joined
with pytest.raises(InputError):
message_unreact(token1, m_id2, 1)
# Trying to unreact to a message with no reacts of that type
message_unreact(token1, m_id1, 1)
with pytest.raises(InputError):
message_unreact(token1, m_id1, 1)
clear()
def test_edit_exceeds_1000_char():
clear()
user = register_n_users(1)
# Create a new channel
channel = channels_create(user["token"], "channel01", is_public=True)
# User sends a message
message = message_send(user["token"], channel["channel_id"],
"test message")
edited_message = "a" * 1001
with pytest.raises(InputError):
assert message_edit(user["token"], message["message_id"],
edited_message)
def test_standup_start_standup_in_another_channel():
'''
Test that a standup can be started in another channel
regardless of one started simultaneously in the first channel
'''
clear()
user = auth_register("*****@*****.**", "password", "Firstname", "Lastname")
channel1 = channels_create(user['token'], "Channel1", True)
channel2 = channels_create(user['token'], "Channel2", True)
standup_start(user['token'], channel1['channel_id'], 1)
# This causes error
with pytest.raises(InputError):
standup_start(user['token'], channel1['channel_id'], 1)
# While this works fine
standup_start(user['token'], channel2['channel_id'], 1)
assert standup_active(user['token'], channel1['channel_id'])
assert standup_active(user['token'], channel2['channel_id'])
time.sleep(2)
def test_edit_continuous_send():
clear()
user = register_n_users(1)
channel_id = channels_create(user["token"], "channela",
is_public=True)["channel_id"]
for i in range(1, 50):
message = message_send(user["token"], channel_id, "message " + str(i))
message_edit(user["token"], message["message_id"],
"edited message " + str(i))
assert channel_messages(
user["token"], channel_id,
0)["messages"][0]["message"] == "edited message " + str(i)
def test_message_send():
'''
Testing message_send function
'''
clear()
#Creating users to create channels
user1 = auth_register("*****@*****.**", "user1pass", "user1", "last1",
None)
user2 = auth_register("*****@*****.**", "user2pass", "user2", "last2",
None)
token1 = user1['token']
token2 = user2['token']
#creating channels
ch_id1 = channels_create(token1, "aGreatChannel", True)['channel_id']
ch_id2 = channels_create(token2, "yetAnotherChannel", False)['channel_id']
#error test
with pytest.raises(InputError):
#message too long
message_send(token1, ch_id1, 'h' * 1001)
with pytest.raises(AccessError):
#user not in channel
message_send(token1, ch_id2, "ilegal")
#creating channel messages
message_send(token1, ch_id1, 'h' * 1000)
message_send(token1, ch_id1, 'hey')
message_send(token2, ch_id2, "hello")
message_send(token2, ch_id2, "hello")
message_send(token2, ch_id2, "hello")
#checking messages have been added
print(channel_messages(token1, ch_id1, 0))
assert len(channel_messages(token1, ch_id1, 0)['messages']) == 2
assert len(channel_messages(token2, ch_id2, 0)['messages']) == 3
def test_authorised_person_not_in_channel():
'''test for access error'''
reset_data()
user1 = auth_register("*****@*****.**", "helloworld", "luc", "zhou")
user2 = auth_register("*****@*****.**", "hellocse", "jiaqi", "zhu")
user3 = auth_register("*****@*****.**", "thisissample", "first", "last")
test_channel = channels.channels_create(user2['token'], "New Channel",
True)
with pytest.raises(AccessError):
channel.channel_invite(user1['token'], test_channel['channel_id'],
user3['u_id'])
def test_standup_start_success():
"""Tests success case for standup_start"""
clear()
valid_user = auth_register("*****@*****.**", "validPassword",
"Validate", "Me")
new_channel = channels_create(valid_user["token"], "new_channel", False)
result = standup_start(valid_user["token"], new_channel["channel_id"], 3)
result_truncated = truncate(result["time_finish"], 0)
current_time = int(time.time())
correct_time_finish = current_time + 3
correct_time_truncated = truncate(correct_time_finish, 0)
assert result_truncated == correct_time_truncated
time.sleep(3)
def test_success_removeowner():
'''test for success'''
reset_data()
owner = auth_register("*****@*****.**", "helloworld", "Cool", "Man")
test_channel = channels.channels_create(owner['token'], "TTress", True)
channel_id = test_channel['channel_id']
new_owner = auth_register("*****@*****.**", "avengers", "Natasha",
"Romanova")
channel.channel_addowner(owner['token'], channel_id, new_owner['u_id'])
assert channel.channel_removeowner(owner['token'], channel_id,
new_owner['u_id']) == {}
def test_create_more_than_one_channel():
'''
Testing when more than one channel is being created.
'''
clear()
new_user = auth_register("*****@*****.**", "password", "Firstname",
"Lastname")
user_token = new_user.get("token")
new_channel_id1 = channels_create(user_token, "channel1", True)
new_channel_id2 = channels_create(user_token, "channel2", True)
new_channel_id3 = channels_create(user_token, "channel3", True)
new_channel_id4 = channels_create(user_token, "channel4", True)
list_of_channels = channels_list(user_token).get('channels')
assert list_of_channels[0]["channel_id"] == new_channel_id1["channel_id"]
assert list_of_channels[0]["name"] == "channel1"
assert list_of_channels[1]["channel_id"] == new_channel_id2["channel_id"]
assert list_of_channels[1]["name"] == "channel2"
assert list_of_channels[2]["channel_id"] == new_channel_id3["channel_id"]
assert list_of_channels[2]["name"] == "channel3"
assert list_of_channels[3]["channel_id"] == new_channel_id4["channel_id"]
assert list_of_channels[3]["name"] == "channel4"
def test_unpin_invalid_msg_id():
'''
Testing for an invalid message ID.
'''
clear()
user_1 = auth_register("*****@*****.**", "password", "User_1",
"User_last_1")
channel_1 = channels_create(user_1.get('token'), 'channel_1', True)
message_info = message_send(user_1.get('token'),
channel_1.get('channel_id'), 'Hello world')
message_pin(user_1.get('token'), message_info.get('message_id'))
with pytest.raises(InputError):
message_unpin(user_1.get('token'), 'invalid_id')
