def test_message_react_multiple_reacts(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_ab adds user_cd to their public channel
channel_invite(user_ab['token'], new_public_channel['channel_id'],
user_cd['u_id'])
msg1 = message_send(user_ab['token'], new_public_channel['channel_id'],
"2 reacts ples")
# both user_ab and cd react to the message; user_cd reacts FIRST
message_react(user_cd['token'], msg1['message_id'], 1)
message_react(user_ab['token'], msg1['message_id'], 1)
# get the list of messages in channel
messages_public = channel_messages(user_ab['token'],
new_public_channel['channel_id'],
0)['messages']
# check for correct reactions (that both users reacted) and correct
# ORDERING
assert messages_public[0]['reacts'] == [{
'react_id':
1,
'u_ids': [user_cd['u_id'], user_ab['u_id']],
'is_this_user_reacted':
True,
}]
def test_invite_AccessError_not_authorised_member():
#invalid test of the authorised user is not already a member of t he channel
# register user1, user2 and user3
# user1 create a new channel, and user2 invite user3
clear()
u1_id = auth.auth_register('*****@*****.**', 'password', 'user1_name',
'user1_name')['u_id']
token_1 = auth.auth_login('*****@*****.**', 'password')['token']
u2_id = auth.auth_register('*****@*****.**', 'password', 'user2_name',
'user2_name')['u_id']
token_2 = auth.auth_login('*****@*****.**', 'password')['token']
u3_id = auth.auth_register('*****@*****.**', 'password', 'user3_name',
'user3_name')['u_id']
auth.auth_login('*****@*****.**', 'password')
channel_id = channels_create(token_1, 'channel_name', True)['channel_id']
with pytest.raises(AccessError):
channel.channel_invite(token_2, channel_id, u3_id)
assert u1_id in channels[0]['all_members']
assert u2_id not in channels[0]['all_members']
assert u3_id not in channels[0]['all_members']
assert channel_id in users[0]['channels']
assert channel_id not in users[1]['channels']
assert channel_id not in users[2]['channels']
# access error when gievn token does not refer to a valid token
with pytest.raises(AccessError):
channel.channel_invite('invalid_token', channel_id, u2_id)
def test_channel_removeowner():
'''
# valid test, it would work well
# register user1, user2 and user3
# user2 creates channel1 and invites user1 and user3
# user2 add user1(automatically) and user3 as owners
# user2 remove user3 owner permission
# user2 remove user1 owner permission(cannot happen since user1 is
# the owner of flockr)
'''
clear()
u1_id = auth.auth_register('*****@*****.**', 'password', 'user1_name',
'user1_name')['u_id']
auth.auth_login('*****@*****.**', 'password')
u2_id = auth.auth_register('*****@*****.**', 'password', 'user2_name',
'user2_name')['u_id']
token_2 = auth.auth_login('*****@*****.**', 'password')['token']
u3_id = auth.auth_register('*****@*****.**', 'password', 'user3_name',
'user3_name')['u_id']
auth.auth_login('*****@*****.**', 'password')
channel_id = channels_create(token_2, 'channel name', True)['channel_id']
channel.channel_invite(token_2, channel_id, u1_id)
channel.channel_invite(token_2, channel_id, u3_id)
assert u1_id not in channels[0]['owner_members']
assert u2_id in channels[0]['owner_members']
assert u3_id not in channels[0]['owner_members']
channel.channel_addowner(token_2, channel_id, u3_id)
assert u3_id in channels[0]['owner_members']
channel.channel_removeowner(token_2, channel_id, u3_id)
assert u3_id not in channels[0]['owner_members']
def test_channel_invite_private_channel(channels_fixture):
"""
pytest: testing channel_invite with private channel
"""
(server_data, channels_fixture) = channels_fixture
# Get user4 and user2's details
user4 = channels_fixture[3]
user2 = channels_fixture[1]
# Get user 2's token and private channel ID
user2_token = channels_fixture[1]["token"]
user2_channel_info = channels_fixture[1]["channels"][0]
#invite user4 into user2's channel using user2's token
channel_invite(server_data, user2_token, user2_channel_info["channel_id"], user4["u_id"])
# After invitation, user4 should become a member of the channel 2
rt_info = channel_details(server_data, user2_token, user2_channel_info["channel_id"])
channel_member_list = rt_info["all_members"]
assert does_member_exist_in_list(channel_member_list, user4["u_id"], user4["name_first"], user4["name_last"])
# And user2 should still remain a member
assert does_member_exist_in_list(channel_member_list, user2["u_id"], user2["name_first"], user2["name_last"])
def test_channel_addowner_user_slackr_owner(auth_fixture):
'''
Test case when authorised user is an owner of the slackr
'''
(server_data, auth_fixture) = auth_fixture
# get user details
tokenslackr = auth_fixture[0]['token']
token1 = auth_fixture[1]['token']
token2 = auth_fixture[2]['token']
u_id2 = auth_fixture[2]['u_id']
# create channels with 1 user (user 1 is owner)
channel_id1 = channels_create(server_data, token1, 'New_Channel',
True)['channel_id']
channel_id2 = channels_create(server_data, token1, 'Another_Channel',
True)['channel_id']
# add user2 as member to channel1
channel_invite(server_data, token1, channel_id1, u_id2)
# slackrowner adds user2 as owner for channel1 (which user2 is a member of) and channel2 (which user2 is not a member of)
channel_addowner(server_data, tokenslackr, channel_id1, u_id2)
channel_addowner(server_data, tokenslackr, channel_id2, u_id2)
# get details of channels
user2_channel_det1 = channel_details(server_data, token2,
channel_id1)['owner_members']
user2_channel_det2 = channel_details(server_data, token2,
channel_id2)['owner_members']
# check that user2 is an owner for both channels
assert any(True for i in user2_channel_det1 if i['u_id'] == u_id2)
assert any(True for i in user2_channel_det2 if i['u_id'] == u_id2)
def test_channel_invite_simple():
clear()
usera, userb = register_n_users(2)
channel_id = channels_create(userb["token"], "userb_channel",
False)["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_members_info = channel_details(userb["token"],
channel_id)["all_members"]
assert usera_info not in channel_members_info
channel_invite(userb["token"], channel_id, usera["u_id"])
updated_channel_members_info = channel_details(userb["token"],
channel_id)["all_members"]
assert usera_info in updated_channel_members_info
def other_init():
'''
fixture for all message tests
'''
global UNIQUE_ID
email_a = f"testauthorised{UNIQUE_ID}@gmail.com"
email_i = f"testinvited{UNIQUE_ID}@gmail.com"
email_u = f"testunauthorised{UNIQUE_ID}@gmail.com"
#Generate test u_ids and tokens
id_and_token_authorised = auth_register(email_a, "goodpassword",
"test_authorised",
"test_authorised")
id_and_token_invited = auth_register(email_i, "goodpassword",
"test_invited", "test_invited")
id_and_token_unauthorised = auth_register(email_u, "goodpassword",
"test_unauthorised",
"test_unauthorised")
#Generate a test channel_id
test_channel_id = channels_create(id_and_token_authorised['token'],
f"test_channel{UNIQUE_ID}", False)
#Initialise a user as a member of the channel
channel_invite(id_and_token_authorised['token'],
test_channel_id['channel_id'], id_and_token_invited['u_id'])
UNIQUE_ID += 1
return [
id_and_token_authorised, id_and_token_invited,
test_channel_id['channel_id'], id_and_token_unauthorised
]
def test_channel_invite_success():
clear()
userA = auth.auth_register('*****@*****.**', '123abc!@#', 'Dennis', 'Lin')
newchannel = channels.channels_create(userA['token'], 'validchannelname', True)
userB = auth.auth_register('*****@*****.**', '123abc!@#', 'Guanbin', 'Wen')
channel.channel_invite(userA['token'], newchannel['channel_id'], userB['u_id'])
assert len(data['channels'][0]['members']) == 2
def test_valid_token_member_channel(channels_fixture):
"""
Pytest: testing channels_list with member channels
"""
(server_data, channels_fixture) = channels_fixture
#Split up the users:
user1 = channels_fixture[0]
user2 = channels_fixture[1]
#Extract the channel informations from the user
channel_list1 = user1["channels"]
channel_list2 = user2["channels"]
#Now invite user2 into user1's channel
channel_invite(server_data, user1["token"], channel_list1[0]["channel_id"],
user2["u_id"])
#Now user 2 should contain 2 channels, one owned, one as member
rt_info = channels_list(server_data, user2["token"])
channels_user2 = rt_info["channels"]
assert does_channel_exist_in_list(channels_user2,
channel_list1[0]["channel_id"],
channel_list1[0]["name"])
assert does_channel_exist_in_list(channels_user2,
channel_list2[0]["channel_id"],
channel_list2[0]["name"])
def test_channel_addowner_already_member():
boyu_dict, _, weiqiang_dict, _, _ = initialise_data()
team_avocado = channels_create(boyu_dict['token'], "teamAvocado", True)
team_avocado_id = team_avocado['channel_id']
channel_invite(boyu_dict['token'], team_avocado_id, weiqiang_dict['u_id'])
channel_addowner(boyu_dict['token'], team_avocado_id,
weiqiang_dict['u_id'])
details = channel_details(weiqiang_dict['token'], team_avocado_id)
assert details == {
'name':
'teamAvocado',
'owner_members': [{
'u_id': boyu_dict['u_id'],
'name_first': 'Boyu',
'name_last': 'Cai',
'profile_img_url': '',
}, {
'u_id': weiqiang_dict['u_id'],
'name_first': 'Weiqiang',
'name_last': 'Zhuang',
'profile_img_url': '',
}],
'all_members': [{
'u_id': boyu_dict['u_id'],
'name_first': 'Boyu',
'name_last': 'Cai',
'profile_img_url': '',
}, {
'u_id': weiqiang_dict['u_id'],
'name_first': 'Weiqiang',
'name_last': 'Zhuang',
'profile_img_url': '',
}],
}
def test_channel_invite_data_store():
boyu_dict, wenyao_dict, _, _, _ = initialise_data()
channel_team_lamb = channels_create(boyu_dict['token'], "teamlamb", True)
channel_team_lamb_id = channel_team_lamb['channel_id']
channel_invite(boyu_dict['token'], channel_team_lamb_id,
wenyao_dict['u_id'])
assert channel_details(boyu_dict['token'], channel_team_lamb_id) == {
'name':
'teamlamb',
'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_channel_leave_member():
boyu_dict, wenyao_dict, _, _, _ = initialise_data()
channel_team_noodles = channels_create(boyu_dict['token'], "teamNoodles",
True)
channel_team_noodles_id = channel_team_noodles['channel_id']
channel_invite(boyu_dict['token'], channel_team_noodles_id,
wenyao_dict['u_id']) # add a member
channel_leave(wenyao_dict['token'],
channel_team_noodles_id) # the member leave the channel
assert channel_details((boyu_dict['token']), channel_team_noodles_id) == {
'name':
'teamNoodles',
'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': '',
}],
}
def test_message_unpin_non_owner(channels_fixture):
'''
Test case for when non owner of a channel tries to unpin a message
'''
(server_data, channels_fixture) = channels_fixture
# get details for user1 and channel 1
token1 = channels_fixture[1]["token"]
token2 = channels_fixture[2]["token"]
uid2 = channels_fixture[2]["u_id"]
channel_id = channels_fixture[1]["channels"][0]["channel_id"]
# user1 invites user2 to channel1
channel_invite(server_data, token1, channel_id, uid2)
# user1 sends a message to channel 1
msgid = message_send(server_data, token1, channel_id,
'Only owners can pin')['message_id']
# user1 pins the message
message_pin(server_data, token1, msgid)
# try to pin the message
with pytest.raises(InputError) as error_raise:
message_unpin(server_data, token2, msgid)
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_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_channel_invite_except():
reset()
u_id, token = get_user("user1")
owner_id, owner_token = get_user("user2")
random_id, random_token = get_user("user3")
channel_id_to_invite = channels.channels_create(owner_token,
"Example Channel",
True)['channel_id']
# InputError:
# channel_id does not refer to a valid channel that the authorised user is part of.
#Assuming 0 is an invalid _id and testing for type error
with pytest.raises(InputError) as e:
assert channel.channel_invite(owner_token, 0, u_id)
#with pytest.raises(InputError) as e:
# assert channel.channel_invite(owner_token,"somestring",u_id)
# u_id does not refer to a valid user
with pytest.raises(InputError) as e:
assert channel.channel_invite(owner_token, channel_id_to_invite, 0)
#with pytest.raises(InputError) as e:
# assert channel.channel_invite(owner_token,channel_id_to_invite,"somestring")
# Access Error:
# The authorised user is not already a member of the channel
with pytest.raises(AccessError) as e:
assert channel.channel_invite(random_token, channel_id_to_invite, u_id)
def test_channel_invite():
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"]
#channels_create() creates a new channel and retuns a {channel_id}
new_channel = channels_create(user_1_token,
"CLASSYISASTATEOFTHEMINDCHANNEL", True)
new_channel_channel_id = new_channel["channel_id"]
channel_invite(user_1_token, new_channel_channel_id, user_2_u_id)
#channel_details() returns {name, owner_members, all_members}
#all_members is a list of dictionaries containing {u_id, name_first, name_last}
details_of_new_channel = channel_details(user_1_token,
new_channel_channel_id)
# A list with dictionaries each with information about owners (which is u_id, name_first, name_last)
list_of_members = details_of_new_channel["all_members"]
valid_user_in_channel = 0
#Checks if the user has joined the channel
for member in list_of_members:
if member["u_id"] == user_2_u_id:
valid_user_in_channel == 1
assert valid_user_in_channel == 1
def test_clear_users():
'''
Test that clear() removes the users[]
'''
# Test basic functionality initially
clear()
f_owner = auth_register('*****@*****.**', 'password', 'Bob', 'Bob')
f_channel = channels_create(f_owner['token'], 'Channel 1', True)
details = channel_details(f_owner['token'], f_channel['channel_id'])
assert len(details['all_members']) == 1
assert len(details['owner_members']) == 1
random_user = auth_register('*****@*****.**', 'password', 'Random',
'User')
channel_invite(f_owner['token'], f_channel['channel_id'],
random_user['u_id'])
details = channel_details(f_owner['token'], f_channel['channel_id'])
assert len(details['all_members']) == 2
assert len(details['owner_members']) == 1
# Cannot register someone who's already a Flockr member
clear()
with pytest.raises(AccessError):
details = channel_details(f_owner['token'], f_channel['channel_id'])
auth_register('*****@*****.**', 'password', 'Bob', 'Bob')
with pytest.raises(InputError):
auth_register('*****@*****.**', 'password', 'Bob', 'Bob')
clear()
auth_register('*****@*****.**', 'password', 'Bob', 'Bob')
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_message_edit_except():
reset()
owner = auth_register('*****@*****.**', 'qwertyui8', 'ownerF', 'ownerL')
owner_id = owner['u_id']
owner_token = owner['token']
owner_handle = 'ownerF'+'ownerL'
member = auth_register('*****@*****.**', 'qwertyui8', 'memberF', 'memberL')
member_id = member['u_id']
member_token = member['token']
member_handle = 'memberF'+'memberL'
#each person create a channel on their own
c_id1 = channels_create(owner_token, 'channel_1', True)['channel_id']
c_id2 = channels_create(member_token, 'channel_2', False)['channel_id']
channel_invite(owner_token, c_id1, member_id) #both owner and member are now in channel 1
m_id1 = message_send(owner_token, c_id1, 'first message in channel 1')['message_id']
m_id2 = message_send(owner_token, c_id1, 'second message in channel 1')['message_id']
m_id3 = message_send(member_token, c_id1, 'third message in channel 1')['message_id'] # the 3rd msg in ch_1 sent by member
m_id4 = message_send(member_token, c_id1, 'fourth message in channel 1')['message_id'] # the 4th msg in ch_1 sent by member
new_mes = 'making changes'
# AccessError (When none of the following are true):
# Message with message_id was sent by the authorised user making this request
# The authorised user is an admin or owner of this channel or the slackr
with pytest.raises(AccessError) as e:
assert message_edit(member_token, m_id2, new_mes)
# member edit member's message but too long
m_id6 = message_send(member_token, c_id1, 'sixth message in channel 1')['message_id']
with pytest.raises(InputError) as e:
assert message_edit(member_token, m_id6, 'h'*1001)
def test_channel_invite1():
other.clear()
owner = auth.auth_register("*****@*****.**", "password", "Homer",
"Simpson")
inved_user = auth.auth_register("*****@*****.**", "password", "Bart",
"Simpson")
channel_1 = channels.channels_create(owner['token'], "channel_1",
False) #this channel will be private
channel.channel_invite(owner['token'], channel_1["channel_id"],
inved_user['u_id'])
owner_dict = {
'u_id': owner['u_id'],
'name_first': 'Homer',
'name_last': 'Simpson',
'profile_img_url': ""
}
inved_user_dict = {
'u_id': inved_user['u_id'],
'name_first': 'Bart',
'name_last': 'Simpson',
'profile_img_url': ""
}
assert channel.channel_details(inved_user['token'],
channel_1['channel_id']) == {
'name': 'channel_1',
'owner_members': [owner_dict],
'all_members':
[owner_dict, inved_user_dict]
}
def test_message_send_except():
reset()
owner = auth_register('*****@*****.**', 'qwertyui8', 'ownerF', 'ownerL')
owner_id = owner['u_id']
owner_token = owner['token']
owner_handle = 'ownerF'+'ownerL'
member = auth_register('*****@*****.**', 'qwertyui8', 'memberF', 'memberL')
member_id = member['u_id']
member_token = member['token']
member_handle = 'memberF'+'memberL'
#each person create a channel on their own
c_id1 = channels_create(owner_token, 'channel_1', True)['channel_id']
c_id2 = channels_create(member_token, 'channel_2', False)['channel_id']
channel_invite(owner_token, c_id1, member_id) #both owner and member are now in channel 1
m_id1 = message_send(owner_token, c_id1, 'first message in channel 1')['message_id']
m_id2 = message_send(owner_token, c_id1, 'second message in channel 1')['message_id']
m_id3 = message_send(member_token, c_id1, 'third message in channel 1')['message_id'] # the 3rd msg in ch_1 sent by member
m_id4 = message_send(member_token, c_id1, 'fourth message in channel 1')['message_id'] # the 4th msg in ch_1 sent by member
new_mes = 'making changes'
# InputError:
# Message is more than 1000 characters
with pytest.raises(InputError):
message_send(owner_token, c_id1, 'long'*250+'l')
# AccessError:
# The authorised user has not joined the channel they are trying to post to
with pytest.raises(AccessError):
message_send(owner_token, c_id2, 'legal message')
def test_channel_invite_public_channel(channels_fixture):
"""
pytest: testing channel_invite with public channel
"""
(server_data, channels_fixture) = channels_fixture
# Getting user 1 and user 2's info
user1 = channels_fixture[0]
user2 = channels_fixture[1]
# Getting user 1's channel info
user1_channel_info = channels_fixture[0]["channels"][0]
#invite user 2 into user 1's channel, as user 1
channel_invite(server_data, user1["token"], user1_channel_info["channel_id"], user2["u_id"])
# After nvitation, user 2 should become a member of the channel
rt_info = channel_details(server_data, user1["token"], user1_channel_info["channel_id"])
channel_member_list = rt_info["all_members"]
assert does_member_exist_in_list(channel_member_list, user2["u_id"], user2["name_first"], user2["name_last"])
# User 1 should also still be in the list
assert does_member_exist_in_list(channel_member_list, user1["u_id"], user1["name_first"], user1["name_last"])
def test_search_string_in_multiple_channels(
reset, create_public_channel, make_user_cd):
# user_ab creates public channel and sends a message to it
new_public_channel, user_ab = create_public_channel
message_send(
user_ab['token'], new_public_channel['channel_id'], "ab's public channel message")
# user_cd creates private channel and sends a message to it
user_cd = make_user_cd
new_private_channel = channels_create(
user_cd['token'], "cd_private", False)
message_send(
user_cd['token'], new_private_channel['channel_id'], "cd's private channel message")
# user_cd invites user_ab to private channel
channel_invite(user_cd['token'],
new_private_channel['channel_id'], user_ab['u_id'])
result_list = search(user_ab['token'], "channel message")['messages']
# getting the message string and user ids that sent them
messages = [message['message'] for message in result_list]
# u_ids = [message['u_id'] for message in result_list]
# asserting the u_ids relate to the messages
assert user_cd['u_id'] in [1, 3]
assert user_ab['u_id'] in [1, 3]
# asserting the messages are in the results
assert "ab's public channel message" in messages
assert "cd's private channel message" in messages
def test_admin_userpermission_change_2to1():
boyu_dict, wenyao_dict = initialise_data()
admin_userpermission_change(boyu_dict['token'], wenyao_dict['u_id'], 1)
# create a channel and add the new flockr owner as a member
channel = channels_create(boyu_dict['token'], "team1", True)
channel_id = channel['channel_id']
channel_invite(boyu_dict['token'], channel_id, wenyao_dict['u_id'])
# check if the new flockr owner has owner permission in the channel
channel_removeowner(wenyao_dict['token'], channel_id, boyu_dict['u_id'])
assert channel_details(wenyao_dict['token'], channel_id) == {
'name':
'team1',
'owner_members': [{
'u_id': wenyao_dict['u_id'],
'name_first': 'Wenyao',
'name_last': 'Chen',
'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_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_removeowner_accesserror_no_permission():
'''
# access error when the authorised user is not
# an owner of the flockr, or an owner of this channel
# register user1, user2 and user3
# user2 create channel1 and invite user1 and user3
# user3 remove user2 owner permission (access error)
'''
clear()
u1_id = auth.auth_register('*****@*****.**', 'password', 'user1_name',
'user1_name')['u_id']
auth.auth_login('*****@*****.**', 'password')
u2_id = auth.auth_register('*****@*****.**', 'password', 'user2_name',
'user2_name')['u_id']
token_2 = auth.auth_login('*****@*****.**', 'password')['token']
u3_id = auth.auth_register('*****@*****.**', 'password', 'user3_name',
'user3_name')['u_id']
token_3 = auth.auth_login('*****@*****.**', 'password')['token']
channel_id = channels_create(token_2, 'channel name', True)['channel_id']
channel.channel_invite(token_2, channel_id, u1_id)
channel.channel_invite(token_2, channel_id, u3_id)
assert u2_id in channels[0]['owner_members']
assert u3_id not in channels[0]['owner_members']
with pytest.raises(AccessError):
assert channel.channel_removeowner(token_3, channel_id, u2_id)
assert u2_id in channels[0]['owner_members']
assert u3_id not in channels[0]['owner_members']
# access error when given token does not refer to a valid user
with pytest.raises(AccessError):
assert channel.channel_removeowner('invalid_token', channel_id, u3_id)
def test_channel_removeowner_user_not_channel_owner(auth_fixture):
'''
Test case when authorised user is not an owner of the channel and is not an owner of the slackr
'''
(server_data, auth_fixture) = auth_fixture
# get user data
token1 = auth_fixture[1]['token']
token3 = auth_fixture[3]['token']
uid2 = auth_fixture[2]['u_id']
uid3 = auth_fixture[3]['u_id']
# create channels with 1 user (user 1 is owner)
pub_channel_id = channels_create(server_data, token1, 'New_Channel', True)['channel_id']
priv_channel_id = channels_create(server_data, token1, 'Priv_Channel', False)['channel_id']
# user2 joins as owner
channel_addowner(server_data, token1, pub_channel_id, uid2)
channel_addowner(server_data, token1, priv_channel_id, uid2)
# user3 join channels as member
channel_invite(server_data, token1, pub_channel_id, uid3)
channel_invite(server_data, token1, priv_channel_id, uid3)
# user3 tries to remove user2 from ownership
with pytest.raises(AccessError) as error_raise:
channel_removeowner(server_data, token3, pub_channel_id, uid2)
with pytest.raises(AccessError) as error_raise:
channel_removeowner(server_data, token3, priv_channel_id, uid2)
def test_removeowner_inputerror_invalid_uid():
'''
# input error when user with user id u_id is not an owner of the channel
# register user1 and user2
# user1 creates channel1, invites user2 and set user2 as owner
# user1 remove user2 owner permission with invalid channel_id
'''
clear()
u1_id = auth.auth_register('*****@*****.**', 'password', 'user1_name',
'user1_name')['u_id']
token_1 = auth.auth_login('*****@*****.**', 'password')['token']
u2_id = auth.auth_register('*****@*****.**', 'password', 'user2_name',
'user2_name')['u_id']
auth.auth_login('*****@*****.**', 'password')
channel_id = channels_create(token_1, 'channel name', True)['channel_id']
channel.channel_invite(token_1, channel_id, u2_id)
assert u1_id in channels[0]['owner_members']
assert u2_id not in channels[0]['owner_members']
with pytest.raises(InputError):
assert channel.channel_removeowner(token_1, channel_id, u2_id)
assert u2_id not in channels[0]['owner_members']
# given u_id does not refer to a valid user
with pytest.raises(InputError):
channel.channel_removeowner(token_1, channel_id, 0)
def initialisation():
clear()
Benjamin = auth_register("*****@*****.**", "password", "Benjamin", "Long") # ID = 0
Ross = auth_register("*****@*****.**", "password", "Ross", "Short") # ID = 1
Alex = auth_register("*****@*****.**", "password", "Alex", "Smith") # ID = 2
channel_id0 = channels_create(Benjamin['token'], "Channel0", True) # ID = 0
channel_id1 = channels_create(Ross['token'], "Channel1", True) # ID = 1
channel_id2 = channels_create(Benjamin['token'], "Channel2", True) # ID = 2
channel_id3 = channels_create(Benjamin['token'], "Channel3", True) # ID = 3
# Everyone is in channel 0
channel_invite(Benjamin['token'], channel_id0['channel_id'], Ross['u_id'])
channel_invite(Benjamin['token'], channel_id0['channel_id'], Alex['u_id'])
# Ross and Alex are in channel 1 but not Benjamin
channel_invite(Ross['token'], channel_id1['channel_id'], Alex['u_id'])
# Ben + Ross == Owner
channel_invite(Benjamin['token'], channel_id2['channel_id'], Ross['u_id'])
channel_invite(Benjamin['token'], channel_id2['channel_id'], Alex['u_id'])
channel_addowner(Benjamin['token'],channel_id2['channel_id'], Ross['u_id'])
# Ben is only member and owner of channel 3
return Benjamin, Ross, Alex, channel_id0, channel_id1, channel_id2, channel_id3
