def test_message_send_no_permission():
reset_data()
owner = auth.auth_register("*****@*****.**", "123456", "Sinha", "Nawa")
channels.channels_create(owner['token'], "Test_channel", False)
channel.channel_leave(owner['token'], 1)
with pytest.raises(AccessError):
message.message_send(owner['token'], 1, "Test message")
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_channel_leave_unauthorised():
clear()
userA = auth.auth_register('*****@*****.**', '123abc!@#', 'Dennis', 'Lin')
userB = auth.auth_register('*****@*****.**', '123abc!@#', 'Guanbin', 'Wen')
newchannel = channels.channels_create(userA['token'], 'validchannelname', True)
with pytest.raises(AccessError):
channel.channel_leave(userB['token'], newchannel['channel_id'])
def test_leave_valid():
"""
Tests if channel_leave works with a valid token and channel ID
"""
# establish a test register
test_dict = auth.auth_register("*****@*****.**", "password", "Bob", "Ross")
# valid channel ID (assigned by channels_create)
c_id_dict = channels.channels_create(test_dict["token"], "test rum ham",
True)
# create a second user and add them to the channel
test_dict_2 = auth.auth_register("*****@*****.**", "password2", "James",
"May")
channel.channel_join(test_dict_2["token"], c_id_dict["channel_id"])
# store our details before the leave
details_before = channel.channel_details(test_dict["token"],
c_id_dict["channel_id"])
# ensure there are two members: test_dict & test_dict_2
assert len(details_before["all_members"]) == 2
assert details_before["all_members"][0]["u_id"] == test_dict["u_id"]
assert details_before["all_members"][1]["u_id"] == test_dict_2["u_id"]
# test channel_leave to have James May(test_dict_2) leave
channel.channel_leave(test_dict_2["token"], c_id_dict["channel_id"])
# check that "test rum ham" only has 1 user in it: Bob Ross
details_after = channel.channel_details(test_dict["token"],
c_id_dict["channel_id"])
assert len(details_after["all_members"]) == 1
assert details_after["all_members"][0]["u_id"] == test_dict["u_id"]
def test_channel_leave():
clear()
userA = auth.auth_register('*****@*****.**', '123abc!@#', 'Dennis', 'Lin')
channels.channels_create(userA['token'], 'validchannelname', True)
assert len(data['channels'][0]['members']) == 1
channel.channel_leave(userA['token'], 0)
assert len(data['channels'][0]['members']) == 0
def test_channel_user_leave():
"""Tests user leave in channel.py for an owner."""
clear()
new_user_1 = auth_register("*****@*****.**", "maccas19201",
"Travis", "Scott")
new_user_2 = auth_register("*****@*****.**", "asheshTheGod912192",
"Ashesh", "God")
new_channel = channels_create(new_user_1["token"], "Spooky Sesh", False)
channel_addowner(new_user_1["token"], new_channel["channel_id"],
new_user_2["u_id"])
channel_leave(new_user_2["token"], new_channel["channel_id"])
channel_info = channel_details(new_user_1["token"],
new_channel["channel_id"])
assert channel_info == {
'name':
'Spooky Sesh',
'owner_members': [{
'u_id': 0,
'name_first': 'Travis',
'name_last': 'Scott',
'profile_img_url': ''
}],
'all_members': [{
'u_id': 0,
'name_first': 'Travis',
'name_last': 'Scott',
'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_channel_leave_correct_details(reset, create_private_channel,
create_user1):
'''
Testing channel is actually updated if user leaves by using channel_details
'''
# creating user and channel
new_ch, owner_info = create_private_channel
user_info = create_user1
# inviting user
channel_invite(owner_info["token"], new_ch["channel_id"],
user_info["u_id"])
# getting details
all_membs = channel_details(owner_info['token'],
new_ch['channel_id'])['all_members']
u_ids = [member['u_id'] for member in all_membs]
# asserting user is in the channel
assert user_info['u_id'] in u_ids
assert len(all_membs) == 3
channel_leave(user_info["token"], new_ch["channel_id"])
# getting details
all_membs = channel_details(owner_info['token'],
new_ch['channel_id'])['all_members']
u_ids = [member['u_id'] for member in all_membs]
assert user_info['u_id'] not in u_ids
assert len(all_membs) == 2
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_leave_accesserror_not_authorised_member():
'''
#change function name from "test_leave_AccessError_not_authorised_member"
#to "test_leave_accesserror_not_authorised_member"
#invalid test of the authorised user is not already a member of t he channel
# register user1 and user2
# user1 create a new channel and DO NOT invite user2
# user2 leave channel with user1's 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']
token_2 = auth.auth_login('*****@*****.**', 'password')['token']
channel_id = channels_create(token_1, 'channel_name', True)['channel_id']
with pytest.raises(AccessError):
channel.channel_leave(token_2, channel_id)
assert u1_id in channels[0]['all_members']
assert u2_id not in channels[0]['all_members']
assert channel_id in users[0]['channels']
assert channel_id not in users[1]['channels']
# access error when given token does not refer to a valid user
with pytest.raises(AccessError):
channel.channel_leave('invalid_token', channel_id)
def test_channel_leave_invalid_user(channel_init):
'''
test_channel_leave_invalid_user
'''
with pytest.raises(AccessError):
#Test with valid channel_id
channel_leave(channel_init[3]['token'], channel_init[2])
def test_channel_leave_invalid_channel(channel_init):
'''
test_channel_leave_invalid_channel
'''
with pytest.raises(InputError):
#Test with valid user
channel_leave(channel_init[0]['token'], "")
def test_message_send_no_permission():
dict = auth.auth_register("*****@*****.**", "123456", "Sinha", "Nawa")
token = dict["token"]
channels.channels_create(token, "Test_channel", False)
channel.channel_leave(token, "1")
with pytest.raises(AccessError):
message.message_send(token, "1", "Test message")
def test_leave_channel_id_invalid():
clear()
user = register_n_users(1)
channel_id = channels_create(user["token"], "channel_A", True)["channel_id"]
invalid_channel_id = channel_id + 1
with pytest.raises(InputError):
channel_leave(user["token"], invalid_channel_id)
def test_channel_leave_invalid_channel_id(reset, create_owner):
'''
Assuming 1321231 is not a valid channel id
'''
owner_info = create_owner
with pytest.raises(InputError):
channel_leave(owner_info['token'], 1321231)
def test_channel_leave_valid():
channel_leave(hamish['token'], channel_id_kelly['channel_id'])
assert (channel_list(hamish['token']) == {
'channels': [{
'channel_id': channel_id_hamish['channel_id'],
'name': 'Hamish_channel'
}]
})
def test_inexist_user_leave_channel_public():
clear()
user_A, user_B = register_n_users(2)
public_channel = channels_create(
user_A["token"], "public_channel", True
) # User A create a public channel and
with pytest.raises(AccessError):
channel_leave(user_B["token"], public_channel["channel_id"])
def test_channel_leave_unauthorized_user(reset, create_public_channel):
'''
Testing leaving a channel as a user with an invalid token
'''
channel_id = create_public_channel[0]
# assuming an invalid token results in an exception
with pytest.raises(Exception):
channel_leave('I am an invalid token', channel_id['channel_id'])
def channel_leave():
'''
Route that allows a user to leave a channel
'''
payload = request.get_json()
token = payload['token']
channel_id = payload['channel_id']
channel.channel_leave(token, channel_id)
return dumps({})
def test_inexist_user_leave_channel_private():
clear()
user_A, user_B = register_n_users(2)
private_channel = channels_create(
user_A["token"], "private_channel", False
) # a private channel
with pytest.raises(AccessError):
channel_leave(user_B["token"], private_channel["channel_id"])
def test_leave_invalid_channel():
'''
Testing when the channel is invalid.
'''
clear()
current_user = auth_register("*****@*****.**", "password", "Firstname", "Lastname")
with pytest.raises(InputError):
channel_leave(current_user.get('token'), 1)
def test_channel_leave_wrong_channel_id():
user_1 = auth_register("*****@*****.**", "12345678", "Devansh",
"Kala")
user_1_user_id = user_1["u_id"]
user_1_token = user_1["token"]
new_channel = channels_create(user_1_token, "NEWCHANNEL", True)
new_channel_channel_id = new_channel["channel_id"]
with pytest.raises(InputError) as e:
channel_leave(user_1_token, new_channel_channel_id * 6789)
def test_invalid_channel_id_leave():
'''for invalid channel id'''
reset_data()
owner = auth_register("*****@*****.**", "avengers", "Natasha",
"Romanova")
channels.channels_create(owner['token'], "Basement", True)
with pytest.raises(InputError):
channel.channel_leave(owner['token'], 839)
def channel_leave():
"""
Function channel leave route
"""
user_channel_id = request.get_json()
channel.channel_leave(user_channel_id["token"],
int(user_channel_id["channel_id"]))
return dumps({})
def test_channel_leave_not_member():
"""Testing leaving a channel but not being a member"""
valid_user = auth_register("*****@*****.**", "validPassword",
"Validate", "Me")
new_channel = channels_create(valid_user["token"], "test_invalid_channel",
False)
new_user = auth_register("*****@*****.**", "newUserPassword", "New",
"User")
with pytest.raises(AccessError):
channel_leave(new_user["token"], new_channel["channel_id"])
def test_channel_leave_private_channel_exception():
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", False)
with pytest.raises(AccessError):
channel.channel_leave(user2['token'], channel_1['channel_id'])
def test_channel_leave_invalid_channel():
other.clear()
user1 = auth.auth_register("*****@*****.**", "password", "John", "Smith")
user2 = auth.auth_register("*****@*****.**", "password", "Will", "Smith")
channels.channels_create(user1['token'], "channel_1", True)
with pytest.raises(InputError):
channel.channel_leave(user2['token'], 999999)
def test_channel_leave_private_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", False)
channel.channel_invite(user1['token'], channel_1['channel_id'],
user2['u_id'])
channel.channel_leave(user2['token'], channel_1['channel_id'])
def test_channel_leave_not_member_of_channel(get_new_user_1, get_new_user_2):
# dummy users.
u_id_1, token_1 = get_new_user_1
u_id_2, token_2 = get_new_user_2
# user_1 creates public channel.
channel1 = channels.channels_create(token_1, valid_channel_name_1, True)
# user_2 is not a member of the channel.
# when user_2 tries to leave channel, throw AccessError.
with pytest.raises(AccessError) as e:
channel.channel_leave(token_2, channel1['channel_id'])
def test_channels_list_left():
reset_data()
# Creating multiple users
user_info = auth_register('*****@*****.**', 'sadsad', 'name', 'lastname')
channels_create(user_info['token'], 'Public', True)
# Leaving the channel
channel_leave(user_info['token'], 1)
assert channels_list(user_info['token']) == {'channels': []}
