def test_channel_join_notowner():
boyu_dict, wenyao_dict, _, _, _ = initialise_data()
channel_team_milk = channels_create(boyu_dict['token'], "teamMilk", True)
channel_team_milk_id = channel_team_milk['channel_id']
channel_join(wenyao_dict['token'], channel_team_milk_id)
# check the values returned by channel_details
assert channel_details(boyu_dict['token'], channel_team_milk_id) == {
'name':
'teamMilk',
'owner_members': [{
'u_id': boyu_dict['u_id'],
'name_first': 'Boyu',
'name_last': 'Cai',
'profile_img_url': '',
}],
'all_members': [{
'u_id': boyu_dict['u_id'],
'name_first': 'Boyu',
'name_last': 'Cai',
'profile_img_url': '',
}, {
'u_id': wenyao_dict['u_id'],
'name_first': 'Wenyao',
'name_last': 'Chen',
'profile_img_url': '',
}],
}
def test_addowner_standard():
info = starter()
u0, u1, u3, c1 = info[0], info[1], info[3], info[4]
# get user information
u3_info = {
'u_id': u3['u_id'],
'name_first': 'Charlie',
'name_last': 'Barry'
}
u0_info = {
'u_id': u0['u_id'],
'name_first': 'King',
'name_last': 'Kingson'
}
u1_info = {
'u_id': u1['u_id'],
'name_first': 'Elizabeth',
'name_last': 'Alexander'
}
# global owner user 0 joins public channel and is added as owner of channel
channel.channel_join(u0['token'], c1['channel_id'])
# user 0 adds user 1 as an owner of the channel
channel.channel_addowner(u0['token'], c1['channel_id'], u1['u_id'])
# user 1 should appear in both channel members and owners lists
details = channel.channel_details(u0['token'], c1['channel_id'])
assert details['owner_members'] == [u3_info, u0_info, u1_info]
assert details['all_members'] == [u3_info, u0_info, u1_info]
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_valid_listall_channel():
'''
Testing if channel_listall works.
'''
clear()
user_1 = auth_register("*****@*****.**", "passwordOne", "Firstone",
"Lastone")
user_1_token = user_1.get("token")
user_2 = auth_register("*****@*****.**", "passwordTwo", "Firsttwo",
"Lasttwo")
user_2_token = user_2.get("token")
channel1 = channels_create(user_1_token, "channel1", True)
channel2 = channels_create(user_1_token, "channel22", True)
channel3 = channels_create(user_1_token, "channel3", False)
channel4 = channels_create(user_1_token, "channel4", False)
channel_join(user_2_token, channel1.get("channel_id"))
channel_join(user_2_token, channel2.get("channel_id"))
channel_list = channels_listall(user_1_token).get('channels')
assert channel_list[0]["channel_id"] == channel1.get("channel_id")
assert channel_list[1]["channel_id"] == channel2.get("channel_id")
assert channel_list[2]["channel_id"] == channel3.get("channel_id")
assert channel_list[3]["channel_id"] == channel4.get("channel_id")
assert len(channel_list) == 4
def test_channel_join_public_channel():
other.clear()
user1 = auth.auth_register("*****@*****.**", "password", "John", "Smith")
user2 = auth.auth_register("*****@*****.**", "password", "Will", "Smith")
channel_1 = channels.channels_create(user1['token'], "channel_1", True)
channel.channel_join(user2['token'], channel_1['channel_id'])
user1_dict = {
'u_id': user1['u_id'],
'name_first': 'John',
'name_last': 'Smith',
'profile_img_url': ""
}
user2_dict = {
'u_id': user2['u_id'],
'name_first': 'Will',
'name_last': 'Smith',
'profile_img_url': ""
}
assert channel.channel_details(user2['token'],
channel_1['channel_id']) == {
'name': 'channel_1',
'owner_members': [user1_dict],
'all_members': [user1_dict, user2_dict]
}
def test_search_other_members():
"""
Test that given messages sent by other user in the channel,
Messages can returned by search when a relevant query string is given.
"""
clear()
# Register users
user = auth_register("*****@*****.**", "Reanxdi920", "Anesthesia", "Rory")
user2 = auth_register("*****@*****.**", "Ascniw101", "Pennicilin", "Mirin")
user3 = auth_register("*****@*****.**", "Cpasmc20", "Borgeis", "Filin")
# Create a channel and let users join
channel = channels_create(user['token'], "Public_channel", True)
channel_join(user2['token'], channel['channel_id'])
channel_join(user3['token'], channel['channel_id'])
# Send some messages (A conversation between 2 members)
message_send(user2['token'], channel['channel_id'], 'Hello there')
message_send(user3['token'], channel['channel_id'], 'Wassup')
msg3 = message_send(user2['token'], channel['channel_id'],
'Who is the owner?')
message_send(user3['token'], channel['channel_id'], 'Not me')
# Calling search for user with the query string 'owner'
result = search(user['token'], "owner")
assert result['messages'][0]['message_id'] == msg3['message_id']
assert result['messages'][0]['u_id'] == user2['u_id']
assert result['messages'][0]['message'] == "Who is the owner?"
def test_channel_invite_member_already_in_channel():
clear()
usera, userb = register_n_users(2)
channel_id = channels_create(userb["token"], "userb_channel",
True)["channel_id"]
usera_info = {
"u_id":
usera["u_id"],
"name_first":
auth_get_user_data_from_id(usera["u_id"])["first_name"],
"name_last":
auth_get_user_data_from_id(usera["u_id"])["last_name"],
"profile_img_url":
auth_get_user_data_from_id(usera["u_id"])["profile_img_url"],
}
channel_join(usera["token"], channel_id)
channel_invite(userb["token"], channel_id, usera["u_id"])
channel_members_info = channel_details(userb["token"],
channel_id)["all_members"]
usera_count = 0
for user in channel_members_info:
if user == usera_info:
usera_count = usera_count + 1
assert usera_count == 1
def test_admin_userpermission_change_to_member():
'''
Test that admin_userpermission_change can set permissions of the user with the given user ID
from owner to member permissions.
'''
clear()
user1 = auth_register('*****@*****.**', 'password', 'Bill', 'Gates')
user2 = auth_register('*****@*****.**', 'password', 'Steve',
'Ballmer')
# First user changes permissions of second user to make them a Flockr owner
admin_userpermission_change(user1['token'], user2['u_id'], 1)
# Second user creates a private channel
f_channel = channels_create(user2['token'], 'Private Channel', False)
# First user is able to join the private channel as they are a Flockr owner
channel_join(user1['token'], f_channel['channel_id'])
channel_leave(user1['token'], f_channel['channel_id'])
# Second user changes permissions of first user to make them a member
admin_userpermission_change(user2['token'], user1['u_id'], 2)
# Check that first user is now a member
# (verified by now not being able to join the private channel)
with pytest.raises(AccessError):
channel_join(user1['token'], f_channel['channel_id'])
def test_user_profile_setname_updated_on_channel():
'''
Test that user's details get updated on the channel
'''
other.clear()
owner = auth.auth_register("*****@*****.**", "testpass", "First", "User")
test_user = auth.auth_register("*****@*****.**", "password", "Notedited",
"Alsonotedited")
channel_1 = channels.channels_create(owner['token'], "Test Channel", True)
channels.channels_create(owner['token'], "Test Channel 2", True)
channel_3 = channels.channels_create(test_user['token'], "Test Channel 2",
True)
channel.channel_join(test_user['token'], channel_1['channel_id'])
channel.channel_join(owner['token'], channel_3['channel_id'])
details = channel.channel_details(test_user['token'],
channel_1['channel_id'])
owner_dict = {
'u_id': owner['u_id'],
'name_first': "First",
'name_last': "User",
'profile_img_url': ""
}
test_user_dict = {
'u_id': test_user['u_id'],
'name_first': "Notedited",
'name_last': "Alsonotedited",
'profile_img_url': ""
}
assert details == {
'name': 'Test Channel',
'owner_members': [owner_dict],
'all_members': [owner_dict, test_user_dict]
}
user.user_profile_setname(test_user['token'], "Newname", "Nowedited")
user.user_profile_setname(owner['token'], "Firstedited", "Nowedited")
details = channel.channel_details(test_user['token'],
channel_1['channel_id'])
owner_dict = {
'u_id': owner['u_id'],
'name_first': "Firstedited",
'name_last': "Nowedited",
'profile_img_url': ""
}
test_user_dict = {
'u_id': test_user['u_id'],
'name_first': "Newname",
'name_last': "Nowedited",
'profile_img_url': ""
}
assert details == {
'name': 'Test Channel',
'owner_members': [owner_dict],
'all_members': [owner_dict, test_user_dict]
}
def channels_create(token, name, is_public):
""" Create a channel using the given parameters """
# Check if name is more than 20 characters long and return InputError if this is the case
if len(name) > 20:
raise error.InputError(
description="The name you entered is more than 20 characters long")
# Generate a channel_id for the new channel
# Simply done in order of time of creation (1..)
# Generation of channel_id will be done in this way as long as ability to delete channels
# remains unimplemented
num_channels = len(database.get_channels())
channel_id = num_channels + 1
# Use database.set_channel to create channel in the database
channel = {'channel_id': channel_id, 'name': name}
database.set_channel(channel)
channel_data = database.get_channel_data(channel_id)
channel_data['is_public'] = is_public
database.set_channel_data(channel_data)
# User who creates the channel joins it automatically
channel_join(token, channel_id)
return {'channel_id': channel_id}
def test_search_results_multiple(user1):
"""
Tests successful uses of search,
focusing on queries that return multiple messages
"""
user2 = auth.auth_register("*****@*****.**", "chocfudge222",
"first_name", "last_name")
test_channel = channels.channels_create(user1["token"], "test_name", True)
channel.channel_join(user2["token"], test_channel["channel_id"])
test_message = "This is a test message."
test_message2 = "This message is a test right?"
message.message_send(user1["token"], test_channel["channel_id"],
test_message)
message.message_send(user2["token"], test_channel["channel_id"],
test_message2)
find_message = other.search(user1["token"], "is a test")['messages']
message_key = list(find_message)[0]
assert message_key["message_id"] == 1
assert message_key["u_id"] == 1
assert message_key["message"] == "This is a test message."
message_key = list(find_message)[1]
assert message_key["message_id"] == 2
assert message_key["u_id"] == 3
assert message_key["message"] == "This message is a test right?"
other.clear()
def test_standup_send_valid():
'''
Test validly sending messages to get buffered in the standup queue
'''
clear()
# Set up users and channel
f_owner = auth_register('*****@*****.**', 'password', 'Flockr', 'Owner')
f_user = auth_register('*****@*****.**', 'password', 'Random', 'User')
f_channel = channels_create(f_owner['token'], 'Test Channel', True)
channel_join(f_user['token'], f_channel['channel_id'])
# Start standup for 5 seconds
standup_start(f_owner['token'], f_channel['channel_id'], 5)
# Users send messages during the standup
message1 = 'F' * 1000
message2 = 'X' * 1000
for _ in range(0, 3):
standup_send(f_owner['token'], f_channel['channel_id'], message1)
standup_send(f_user['token'], f_channel['channel_id'], message2)
# Check only one message (containing all the standup messages) is sent after the standup ends
time.sleep(6)
messages = channel_messages(f_owner['token'], f_channel['channel_id'], 0)
assert len(messages['messages']) == 1
def test_channel_join_is_private():
clear()
userA = auth.auth_register('*****@*****.**', '123abc!@#', 'Dennis', 'Lin')
userB = auth.auth_register('*****@*****.**', '123abc!@#', 'Guanbin', 'Wen')
newchannel = channels.channels_create(userA['token'], 'validchannelname', False) # this channel is private
with pytest.raises(AccessError):
channel.channel_join(userB['token'], newchannel['channel_id'])
def test_channel_join_flockr_owner_joins_private_channel():
clear()
userA = auth.auth_register('*****@*****.**', '123abc!@#', 'Dennis', 'Lin')
userB = auth.auth_register('*****@*****.**', '123abc!@#', 'Guanbin', 'Wen')
newchannel = channels.channels_create(userB['token'], 'validchannelname', False)
channel.channel_join(userA['token'], newchannel['channel_id'])
assert len(data['channels'][0]['members']) == 2
def test_message_edit():
database.reset()
#send a message
result = get_user("user1")
u_id = result['u_id']
token = result['token']
temp = channels.channels_create(token, "channel1", True)
channel_id = temp['channel_id']
msg = message.message_send(token, channel_id, "hello")
message_id = msg['message_id']
#edit the message
return_val = message.message_edit(token, message_id, "hi")
assert return_val == {}
#edit the message to an empty string so the message is deleted
message.message_edit(token, message_id, "")
#try to delete the message which is deleted
with pytest.raises(InputError) as e:
message.message_remove(token, message_id)
#have a new user join the channel and send a message
result = get_user("user2")
u_id2 = result['u_id']
token2 = result['token']
channel.channel_join(token2, channel_id)
msg2 = message.message_send(token2, channel_id, "hello")
#admin edit the new message
temp2 = message.message_edit(token, msg2['message_id'], "hi")
assert temp2 == {}
#new user edit him message
temp3 = message.message_edit(token2, msg2['message_id'], "hillo")
assert temp3 == {}
def test_invalid_channel_id_join():
'''test for invalid channel id'''
reset_data()
member = auth_register("*****@*****.**", "helloworld", "Cool", "Man")
with pytest.raises(InputError):
channel.channel_join(member['token'], 839)
def test_message_remove():
#create a message
database.reset()
result = get_user("user1")
u_id = result['u_id']
token = result['token']
channel_result = channels.channels_create(token, "channel1", True)
msgid1 = message.message_send(token, channel_result['channel_id'], "hello")
msg1 = msgid1['message_id']
#remove the message
message.message_remove(token, msg1)
#have a new user and join the channel
result = get_user("user2")
u_id1 = result['u_id']
token1 = result['token']
channel.channel_join(token1, channel_result['channel_id'])
#new user send a message
msgid2 = message.message_send(token1, channel_result['channel_id'], "hello")
msg2 = msgid2['message_id']
#admin remove the new message
message.message_remove(token, msg2)
#new user send another message
msgid3 = message.message_send(token1, channel_result['channel_id'], "wow")
#new user remove the message
message.message_remove(token1, msgid3['message_id'])
def test_show_details_member():
'''test for member access'''
reset_data()
owner = auth_register("*****@*****.**", "hellocse", "jiaqi", "zhu")
member = auth_register("*****@*****.**", "iamrobert", "Robert", "Cad")
member2 = auth_register("*****@*****.**", "happycse", 'Sinha', "Sc")
test_channel = channels.channels_create(owner['token'], "New Channel",
True)
channel_id = test_channel['channel_id']
channel.channel_join(member['token'], channel_id)
channel.channel_join(member2['token'], channel_id)
assert channel.channel_details(member['token'], channel_id) == {
'name':
'New Channel',
'owner_members': [{
'u_id': owner['u_id'],
'name_first': 'jiaqi',
'name_last': 'zhu',
}],
'all_members': [{
'u_id': owner['u_id'],
'name_first': 'jiaqi',
'name_last': 'zhu',
}, {
'u_id': member['u_id'],
'name_first': 'Robert',
'name_last': 'Cad',
}, {
'u_id': member2['u_id'],
'name_first': 'Sinha',
'name_last': 'Sc',
}]
}
def test_other_search():
'''
Test that a user can search for messages in channels that he is a part of
'''
other.clear()
messages_test = [
'test message 1',
'test message 2',
'test message 3'
]
user1 = auth.auth_register('*****@*****.**', 'abcd1234', 'Will', 'Smith')
user2 = auth.auth_register('*****@*****.**', 'abcd1234', 'John', 'Smith')
channel_1 = channels.channels_create(user1['token'], 'channel_1', True)
channels.channels_create(user1['token'], 'channel_2', True)
channel.channel_join(user2['token'], channel_1['channel_id'])
message.message_send(user2['token'], channel_1['channel_id'], 'test message 1')
message.message_send(user2['token'], channel_1['channel_id'], 'test message 2')
message.message_send(user2['token'], channel_1['channel_id'], 'test message 3')
message.message_send(user2['token'], channel_1['channel_id'], 'this message should not be found')
query_messages = other.search(user2['token'], 'test')
i = 0
for messages_found in query_messages['messages']:
assert messages_found['message'] == messages_test[i]
i += 1
assert len(query_messages['messages']) == 3
def test_userpermission_change_demote(
reset, create_private_channel, make_user_cd, make_user_ef):
'''
Testing demoting a user restricts him to join private channels
'''
# creating a private channel
channel_id, owner_info = create_private_channel
# since owner is the first user who signs up in this
# test, he should be a slackr owner
# create new user
user_info = make_user_cd
# promoting user
userpermission_change(owner_info['token'], user_info['u_id'], SLACKR_OWNER)
# Inviting new user
channel_invite(owner_info['token'],
channel_id['channel_id'], user_info['u_id'])
# demoting user
userpermission_change(owner_info['token'],
user_info['u_id'], SLACKR_MEMBER)
# User leaves the channel
channel_leave(user_info['token'], channel_id['channel_id'])
# testing joining a private channel
with pytest.raises(AccessError):
channel_join(user_info['token'], channel_id['channel_id'])
def test_adder_not_member():
clear()
user_0, user_1, user_2 = create_three_test_users()
public_channel = channels_create(user_0['token'], "name", True)
channel_join(user_2['token'], public_channel['channel_id'])
with pytest.raises(error.AccessError):
assert channel_addowner(user_1['token'], public_channel['channel_id'], user_2['u_id']) == {}
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_channel_details_two_users():
other.clear()
user_1 = auth.auth_register("*****@*****.**", "abcd1234", "John",
"Smith")
user_2 = auth.auth_register("*****@*****.**", "abcd1234", "Will",
"Smith")
channel_1 = channels.channels_create(user_1['token'], "Test Channel", True)
channel.channel_join(user_2['token'], channel_1['channel_id'])
assert channel.channel_details(user_1['token'],
channel_1['channel_id']) == {
'name':
"Test Channel",
'owner_members': [{
'u_id': 1,
'name_first': "John",
'name_last': "Smith",
'profile_img_url': ""
}],
'all_members': [{
'u_id': 1,
'name_first': "John",
'name_last': "Smith",
'profile_img_url': ""
}, {
'u_id': 2,
'name_first': "Will",
'name_last': "Smith",
'profile_img_url': ""
}]
}
other.clear()
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_join_standard():
info = starter()
u1, u2, u3, c1 = info[1], info[2], info[3], info[4]
# store user information
u3_info = {
'u_id': u3['u_id'],
'name_first': 'Charlie',
'name_last': 'Barry'
}
u1_info = {
'u_id': u1['u_id'],
'name_first': 'Elizabeth',
'name_last': 'Alexander'
}
u2_info = {'u_id': u2['u_id'], 'name_first': 'Jane', 'name_last': 'Anton'}
# user 1 joins public channel
channel.channel_join(u1['token'], c1['channel_id'])
details = channel.channel_details(u1['token'], c1['channel_id'])
# user 1 should appear in channel members list
assert details['all_members'] == [u3_info, u1_info]
# user 1 should NOT be in channel owners list
assert details['owner_members'] == [u3_info]
# user 2 joins public channel
channel.channel_join(u2['token'], c1['channel_id'])
details = channel.channel_details(u2['token'], c1['channel_id'])
# both users 1 and 2 should appear in list of channel members
assert details['all_members'] == [u3_info, u1_info, u2_info]
# users 1 and 2 should NOT appear in channel owners list
assert details['owner_members'] == [u3_info]
def test_message_prune_invalid():
''' Invalid 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')
w_user = auth_register('*****@*****.**', 'password', 'Weird', '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
# Invalid
with pytest.raises(AccessError):
message_prune(c_owner['token'] + 'rAnd0M_p@dd1nG', channel['channel_id'], 3)
with pytest.raises(InputError):
message_prune(c_owner['token'], channel['channel_id'] + 1000, 3)
with pytest.raises(AccessError):
# w_user not in channel
message_prune(w_user['token'], channel['channel_id'], 3)
with pytest.raises(AccessError):
message_prune(r_user['token'], channel['channel_id'], 3)
with pytest.raises(InputError):
# Note that normally, requesting the '/prune' command adds another message
# but in this isolated test case, it doesn't
message_prune(c_owner['token'], channel['channel_id'], 4)
def test_search_multiple_users():
user1_info = auth.auth_register('a@gmail', '123', 'aName', 'aLastname')
user2_info = auth.auth_register('b@gmail', '321', 'bName', 'bLastname')
# Creating the channel
channels.channels_create(user1_info['token'], 'a', True)
# User 2 joining the channel
channel.channel_join(user2_info['token'], 1)
# User 1 & 2 messaging the channel
message.message_send(user1_info['token'], 1,
"hello there my name is User1")
message.message_send(user2_info['token'], 1,
"hello User1 my name is User2")
# Finding a timestamp
tmp = channel.channel_messages(user2_info['token'], 1, 0)
message1 = tmp['messages'][0]
timestamp1 = message1['time_created']
message2 = tmp['messages'][1]
timestamp2 = message2['time_created']
# Giving all messages containing the query string
assert other.search(user1_info['token'], "hello") == {
'messages': [{
'message_id': 1,
'u_id': 1,
'message': 'hello there my name is User1',
'time_created': timestamp1,
}, {
'message_id': 2,
'u_id': 2,
'message': 'hello User1 my name is User2',
'time_created': timestamp2,
}],
}
def test_standup_start1():
"""
Tests if standup_start and standup_send works.
"""
clear()
user1 = auth.auth_register("*****@*****.**", "password", "Bilbo", "Baggins")
user2 = auth.auth_register("*****@*****.**", "password", "Frodo", "Baggins")
user3 = auth.auth_register("*****@*****.**", "password", "Master", "Sauron")
channel_dict = channels.channels_create(user1['token'], "test_channel", True)
channel.channel_join(user2['token'], channel_dict['channel_id'])
channel.channel_join(user3['token'], channel_dict['channel_id'])
standup.standup_start(user1['token'], channel_dict['channel_id'], 3)
standup.standup_send(user1['token'], channel_dict['channel_id'], "message1")
standup.standup_send(user2['token'], channel_dict['channel_id'], "message2")
standup.standup_send(user3['token'], channel_dict['channel_id'], "message3")
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 len(message_dict['messages']) == 1
assert message_dict['messages'][0]['message'] == ("bilbobaggins: message1\n" +
"frodobaggins: message2\n" +
"mastersauron: message3")
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_channels_list():
'''
Tests for channels list
'''
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']
#testing function returns an empty list before any channels have been made
assert channels_list(token1) == {'channels':[]}
#Creating channels to test channels_list.
#check for public channels
channels_create(token1, "aGreatChannel", True)
#check not public channels
ch_id2 = channels_create(token2, "yetAnotherChannel", True)['channel_id']
#check channels with same name
channels_create(token1, "SameName", True)
#Test for user2
assert len(channels_list(token1)['channels']) == 2
#Test for user1
assert len(channels_list(token2)['channels']) == 1
#check once user has joined channel it adds a member
channel_join(token1, ch_id2)
assert len(channels_list(token1)['channels']) == 3
