def test_channel_removeowner_stat():
clear_v1()
result1 = auth_register_v2('*****@*****.**', 'password', 'comp', 'student')
result2 = auth_register_v2('*****@*****.**', 'password', 'comp', 'student')
channel1 = channels_create_v2(result2['token'], "The party channel 1", True)
channel_addowner_v1(result2['token'], channel1['channel_id'], result1['auth_user_id'])
channel_removeowner_v1(result1['token'], channel1['channel_id'], result2['auth_user_id'])
output = user_stats(result1['token'])
output1 = user_stats(result2['token'])
dreams = users_stats(result1['token'])
assert len(output['user_stats']) == 4
assert output['user_stats']['channels_joined'][-1]['num_channels_joined'] == 1
assert output['user_stats']['dms_joined'][-1]['num_dms_joined'] == 0
assert output['user_stats']['messages_sent'][-1]['num_messages_sent'] == 0
assert output['user_stats']['involvement_rate'] == 1
assert len(output1['user_stats']) == 4
assert output1['user_stats']['channels_joined'][-1]['num_channels_joined'] == 1
assert output1['user_stats']['dms_joined'][-1]['num_dms_joined'] == 0
assert output1['user_stats']['messages_sent'][-1]['num_messages_sent'] == 0
assert output1['user_stats']['involvement_rate'] == 1
assert len(dreams['dreams_stats']) == 4
assert dreams['dreams_stats']['channels_exist'][-1]['num_channels_exist'] == 1
assert dreams['dreams_stats']['dms_exist'][-1]['num_dms_exist'] == 0
assert dreams['dreams_stats']['messages_exist'][-1]['num_messages_exist'] == 0
assert dreams['dreams_stats']['utilization_rate'] == 2/2
def test_success_remove_multiple(create_input):
# Add extra owner to First Channel
assert channel_addowner_v1(create_input[0][0]["token"],
create_input[1][0]["channel_id"],
create_input[0][2]["auth_user_id"]) == {}
# length of *_members for First Channel before remove
assert len(
channel_details_v2(
create_input[0][0]["token"],
create_input[1][0]["channel_id"])["owner_members"]) == 3
assert len(
channel_details_v2(
create_input[0][0]["token"],
create_input[1][0]["channel_id"])["all_members"]) == 4
assert channel_removeowner_v1(create_input[0][0]["token"],
create_input[1][0]["channel_id"],
create_input[0][1]["auth_user_id"]) == {}
assert channel_removeowner_v1(create_input[0][0]["token"],
create_input[1][0]["channel_id"],
create_input[0][2]["auth_user_id"]) == {}
# length of *_members for First Channel after remove; testing for all users
assert len(
channel_details_v2(
create_input[0][0]["token"],
create_input[1][0]["channel_id"])["owner_members"]) == 1
assert len(
channel_details_v2(
create_input[0][0]["token"],
create_input[1][0]["channel_id"])["all_members"]) == 4
assert len(
channel_details_v2(
create_input[0][1]["token"],
create_input[1][0]["channel_id"])["owner_members"]) == 1
assert len(
channel_details_v2(
create_input[0][1]["token"],
create_input[1][0]["channel_id"])["all_members"]) == 4
assert len(
channel_details_v2(
create_input[0][2]["token"],
create_input[1][0]["channel_id"])["owner_members"]) == 1
assert len(
channel_details_v2(
create_input[0][2]["token"],
create_input[1][0]["channel_id"])["all_members"]) == 4
assert len(
channel_details_v2(
create_input[0][4]["token"],
create_input[1][0]["channel_id"])["owner_members"]) == 1
assert len(
channel_details_v2(
create_input[0][4]["token"],
create_input[1][0]["channel_id"])["all_members"]) == 4
def test_channel_add_leave_owner_v1_errors(user_setup, channel_setup):
'''
#test the errors for channel_addowner_v1 and channel_removeowner_v1
'''
# Test 6:
# user is currently the only owner
with pytest.raises(AccessError):
channel_removeowner_v1(make_token(1), 1, 1)
channel_invite_v2(make_token(1), 1, 0) # invite gungeet
channel_invite_v2(make_token(1), 1, 2) # invite chris
channel_invite_v2(make_token(1), 1, 3)
# Test 6:
# invalid channel
with pytest.raises(InputError):
channel_addowner_v1(make_token(1), 10, 0)
# Test 7:
# authorised user doesn't exist
with pytest.raises(AccessError):
channel_addowner_v1(make_token(10), 1, 0)
# Test 8:
# user is already an owner
with pytest.raises(InputError):
channel_addowner_v1(make_token(1), 1, 1)
# Test 9:
# authorised user is not an owner
with pytest.raises(AccessError):
channel_addowner_v1(make_token(3), 1, 2)
# Test 10:
# invalid channel
with pytest.raises(InputError):
channel_removeowner_v1(make_token(0), 1, 2)
# Test 11:
# authorised user doesn't exist
with pytest.raises(AccessError):
channel_removeowner_v1(make_token(10), 1, 1)
# Test 12:
# invalid channel
with pytest.raises(InputError):
channel_addowner_v1(make_token(1), 10, 0)
# Test 13:
# authorised user is not an owner
with pytest.raises(AccessError):
channel_removeowner_v1(make_token(2), 1, 1)
# Test 14:
# user is not the owner of the channel
with pytest.raises(InputError):
channel_removeowner_v1(make_token(1), 1, 2)
def test_channel_removeowner_v1_user_id_not_an_owner(reg_user,
basic_channel_name):
clear_v2()
channel_name = basic_channel_name
token_1 = reg_user(0)['token']
auth_user_id_2 = reg_user(1)['auth_user_id']
channel_id = channels_create_v2(token_1, channel_name, True)['channel_id']
#join
with pytest.raises(InputError):
channel_removeowner_v1(
token_1, channel_id,
auth_user_id_2) #this user is not an owner of the channel
def test_channel_removeowner_v1_only_owner_in_channel(reg_user,
basic_channel_name):
clear_v2()
channel_name = basic_channel_name
basic_user = reg_user(0)
channel_id = channels_create_v2(basic_user['token'], channel_name,
True)['channel_id']
with pytest.raises(InputError):
channel_removeowner_v1(
basic_user['token'], channel_id, basic_user['auth_user_id']
) #this is the only owner of the channel cant remove the only owner
def test_channel_removeowner_v1_token(reg_user, basic_channel_name):
clear_v2()
channel_name = basic_channel_name
token_1 = reg_user(0)['token']
auth_user_id_2 = reg_user(1)['auth_user_id']
fake_token = 'random values'
channel_id = channels_create_v2(token_1, channel_name, True)['channel_id']
channel_addowner_v1(token_1, channel_id,
auth_user_id_2) #add this user as the owner
with pytest.raises(AccessError):
channel_removeowner_v1(fake_token, channel_id,
auth_user_id_2) #invalid token
def test_remove_nonowner(test_data):
_, a_data, b_data, c_data, a_ch_id, c_ch_id = test_data
channel_join_v2(c_data["token"], a_ch_id)
channel_join_v2(a_data["token"], c_ch_id)
channel_join_v2(b_data["token"], c_ch_id)
"""
channel a
owners
a
members
a, b, c
channel c
owners
c
members
c, a, b
"""
with pytest.raises(InputError):
channel_removeowner_v1(a_data["token"], a_ch_id,
b_data["auth_user_id"])
channel_removeowner_v1(a_data["token"], a_ch_id,
c_data["auth_user_id"])
channel_removeowner_v1(c_data["token"], c_ch_id,
a_data["auth_user_id"])
channel_removeowner_v1(c_data["token"], c_ch_id,
b_data["auth_user_id"])
def test_fail_user_not_owner(create_input):
# length of *_members for First Channel
assert len(
channel_details_v2(
create_input[0][0]["token"],
create_input[1][0]["channel_id"])["owner_members"]) == 2
assert len(
channel_details_v2(
create_input[0][0]["token"],
create_input[1][0]["channel_id"])["all_members"]) == 3
with pytest.raises(InputError):
channel_removeowner_v1(create_input[0][0]["token"],
create_input[1][0]["channel_id"],
create_input[0][4]["auth_user_id"])
def test_remove_owner(reg_user, basic_channel_name):
clear_v2()
owner_user = reg_user(0)
basic_user = reg_user(1)
channel_id = channels_create_v2(owner_user['token'], basic_channel_name,
True)['channel_id']
channel_addowner_v1(owner_user['token'], channel_id,
basic_user['auth_user_id'])
channel_removeowner_v1(basic_user['token'], channel_id,
owner_user['auth_user_id'])
channel_owners = channel_details_v2(basic_user['token'],
channel_id)['owner_members']
owner_ids = [owner['u_id'] for owner in channel_owners]
assert owner_user[
'auth_user_id'] not in owner_ids # Check that owner has been removed
def channel_removeowner():
parameters = request.get_json()
token = parameters['token']
channel_id = parameters['channel_id']
u_id = parameters['u_id']
output = channel_removeowner_v1(token, channel_id, u_id)
return dumps(output)
def channel_removeowner():
info = request.get_json()
token = info["token"]
channel_id = info["channel_id"]
u_id = info["u_id"]
channel_removeowner = channel_removeowner_v1(token, channel_id, u_id)
return dumps(channel_removeowner)
def test_channel_removeowner_v1_auth_user_not_owner_of_channel(
reg_user, basic_channel_name):
clear_v2()
channel_name = basic_channel_name
token_1 = reg_user(0)['token']
user_register2 = reg_user(1)
user_register3 = reg_user(2)
channel_id = channels_create_v2(token_1, channel_name, True)['channel_id']
#join
channel_join_v2(user_register2['token'], channel_id)
channel_join_v2(user_register3['token'], channel_id)
channel_addowner_v1(token_1, channel_id, user_register3['auth_user_id'])
#user 2 cant remove user 3 // promote user 3 to owner
with pytest.raises(AccessError):
channel_removeowner_v1(
user_register2['token'], channel_id, user_register3['auth_user_id']
) #a normal member of the channel cant remove a owner of the channel
def test_fail_no_permission(create_input):
# length of *_members for Third Channel before remove
assert len(
channel_details_v2(
create_input[0][2]["token"],
create_input[1][2]["channel_id"])["owner_members"]) == 2
assert len(
channel_details_v2(
create_input[0][2]["token"],
create_input[1][2]["channel_id"])["all_members"]) == 2
assert channel_join_v2(create_input[0][4]["token"],
create_input[1][2]["channel_id"]) == {}
with pytest.raises(AccessError):
channel_removeowner_v1(create_input[0][4]["token"],
create_input[1][2]["channel_id"],
create_input[0][2]["auth_user_id"])
def test_normal(test_data):
_, a_data, b_data, c_data, a_ch_id, c_ch_id = test_data
channel_join_v2(c_data["token"], a_ch_id)
channel_join_v2(a_data["token"], c_ch_id)
channel_join_v2(b_data["token"], c_ch_id)
"""
channel a
owners
a
members
a, b, c
channel c
owners
c
members
c, a, b
"""
# only owners can remove owners (including themselves)
# if any of the added owners are not owners, removeowner will raise an error
# a add b to a_channel, b removes b
channel_addowner_v1(a_data["token"], a_ch_id, b_data["auth_user_id"])
assert channel_removeowner_v1(b_data["token"], a_ch_id,
b_data["auth_user_id"]) == {}
# a add c to a_channel, c removes c
channel_addowner_v1(a_data["token"], a_ch_id, c_data["auth_user_id"])
assert channel_removeowner_v1(c_data["token"], a_ch_id,
c_data["auth_user_id"]) == {}
#c add a to c_channel, a removes a
channel_addowner_v1(c_data["token"], c_ch_id, a_data["auth_user_id"])
assert channel_removeowner_v1(a_data["token"], c_ch_id,
a_data["auth_user_id"]) == {}
# c add b to c_channel, b removes b
channel_addowner_v1(c_data["token"], c_ch_id, b_data["auth_user_id"])
assert channel_removeowner_v1(b_data["token"], c_ch_id,
b_data["auth_user_id"]) == {}
def test_only_owner(test_data):
global_owner, a_data, _, c_data, a_ch_id, c_ch_id = test_data
channel_join_v2(global_owner["token"], a_ch_id)
channel_join_v2(global_owner["token"], c_ch_id)
with pytest.raises(InputError):
channel_removeowner_v1(a_data["token"], a_ch_id,
a_data["auth_user_id"])
channel_removeowner_v1(global_owner["token"], a_ch_id,
a_data["auth_user_id"])
channel_removeowner_v1(c_data["token"], c_ch_id,
c_data["auth_user_id"])
channel_removeowner_v1(global_owner["token"], a_ch_id,
a_data["auth_user_id"])
def test_auth_user_dreams_owner(test_data):
global_owner, a_data, b_data, c_data, a_ch_id, c_ch_id = test_data
channel_join_v2(c_data["token"], a_ch_id)
channel_join_v2(a_data["token"], c_ch_id)
channel_join_v2(b_data["token"], c_ch_id)
channel_join_v2(global_owner["token"], a_ch_id)
channel_join_v2(global_owner["token"], c_ch_id)
channel_addowner_v1(a_data["token"], a_ch_id, b_data["auth_user_id"])
channel_addowner_v1(a_data["token"], a_ch_id, c_data["auth_user_id"])
channel_addowner_v1(c_data["token"], c_ch_id, a_data["auth_user_id"])
channel_addowner_v1(c_data["token"], c_ch_id, b_data["auth_user_id"])
"""
channel a
owners
a, b, c
members
a, b, c, g.o
channel c
owners
c, a, b
members
c, a, b, g.o
"""
assert channel_removeowner_v1(global_owner["token"], a_ch_id,
a_data["auth_user_id"]) == {}
assert channel_removeowner_v1(global_owner["token"], a_ch_id,
b_data["auth_user_id"]) == {}
assert channel_removeowner_v1(global_owner["token"], c_ch_id,
a_data["auth_user_id"]) == {}
assert channel_removeowner_v1(global_owner["token"], c_ch_id,
c_data["auth_user_id"]) == {}
def test_remove_nonmember(test_data):
_, a_data, b_data, c_data, a_ch_id, c_ch_id = test_data
with pytest.raises(InputError):
channel_removeowner_v1(a_data["token"], a_ch_id,
c_data["auth_user_id"])
channel_removeowner_v1(c_data["token"], c_ch_id,
a_data["auth_user_id"])
channel_removeowner_v1(c_data["token"], c_ch_id,
b_data["auth_user_id"])
def test_normal(test_data):
_, a_data, b_data, c_data, a_ch_id, c_ch_id = test_data
d_data = auth_register_v2('*****@*****.**', '123456', 'Dan', 'Don')
channel_join_v2(c_data["token"], a_ch_id)
channel_join_v2(d_data["token"], a_ch_id)
channel_join_v2(a_data["token"], c_ch_id)
channel_join_v2(b_data["token"], c_ch_id)
channel_join_v2(d_data["token"], c_ch_id)
channel_addowner_v1(a_data["token"], a_ch_id, b_data["auth_user_id"])
channel_addowner_v1(a_data["token"], a_ch_id, c_data["auth_user_id"])
channel_addowner_v1(c_data["token"], c_ch_id, a_data["auth_user_id"])
channel_addowner_v1(c_data["token"], c_ch_id, b_data["auth_user_id"])
"""
channel a
owners
a, b, c
members
a, b, c, d
channel c
owners
c, a, b
members
c, a, b, d
"""
channel_removeowner_v1(a_data["token"], a_ch_id, b_data["auth_user_id"])
with pytest.raises(AccessError):
channel_addowner_v1(b_data["token"], a_ch_id, d_data["auth_user_id"])
channel_removeowner_v1(a_data["token"], a_ch_id, c_data["auth_user_id"])
with pytest.raises(AccessError):
channel_addowner_v1(c_data["token"], a_ch_id, d_data["auth_user_id"])
channel_removeowner_v1(c_data["token"], c_ch_id, a_data["auth_user_id"])
with pytest.raises(AccessError):
channel_addowner_v1(a_data["token"], c_ch_id, d_data["auth_user_id"])
channel_removeowner_v1(c_data["token"], c_ch_id, b_data["auth_user_id"])
with pytest.raises(AccessError):
channel_addowner_v1(b_data["token"], c_ch_id, d_data["auth_user_id"])
def test_success_remove_with_global_owner(create_input):
# length of *_members for Third Channel before remove
assert len(
channel_details_v2(
create_input[0][2]["token"],
create_input[1][2]["channel_id"])["owner_members"]) == 2
assert len(
channel_details_v2(
create_input[0][2]["token"],
create_input[1][2]["channel_id"])["all_members"]) == 2
# Global owner is not part of Third Channel, yet can still remove owners
assert channel_removeowner_v1(create_input[0][0]["token"],
create_input[1][2]["channel_id"],
create_input[0][2]["auth_user_id"]) == {}
assert len(
channel_details_v2(
create_input[0][3]["token"],
create_input[1][2]["channel_id"])["owner_members"]) == 1
assert len(
channel_details_v2(
create_input[0][3]["token"],
create_input[1][2]["channel_id"])["all_members"]) == 2
def test_token_invalid(create_input):
# token does not exist
with pytest.raises(AccessError):
channel_removeowner_v1("invalidtoken",
create_input[1][0]["channel_id"],
create_input[0][0]["auth_user_id"])
def test_invalid_channel_id(test_data):
_, a_data, b_data, c_data, a_ch_id, c_ch_id = test_data
channel_addowner_v1(a_data["token"], a_ch_id, b_data["auth_user_id"])
channel_join_v2(b_data["token"], c_ch_id)
channel_addowner_v1(c_data["token"], c_ch_id, b_data["auth_user_id"])
with pytest.raises(InputError):
channel_removeowner_v1(a_data["token"], 123456, b_data["auth_user_id"])
channel_removeowner_v1(a_data["token"], -1231, b_data["auth_user_id"])
channel_removeowner_v1(a_data["token"], "abcdefgha",
b_data["auth_user_id"])
channel_removeowner_v1(c_data["token"], "aBNNaasdAIWK",
b_data["auth_user_id"])
channel_removeowner_v1(c_data["token"], "ashd8AOw51234AI",
b_data["auth_user_id"])
channel_removeowner_v1(c_data["token"], "AuNAD)(A*H@Emas90djam2",
b_data["auth_user_id"])
def test_invalid_token(test_data):
_, a_data, b_data, _, a_ch_id, _ = test_data
channel_addowner_v1(a_data["token"], a_ch_id, b_data["auth_user_id"])
"""
channel a
owners
a, b
members
a, b
"""
with pytest.raises(AccessError):
channel_removeowner_v1(0, a_ch_id, b_data)
channel_removeowner_v1(12319241, a_ch_id, b_data)
channel_removeowner_v1("", a_ch_id, b_data)
channel_removeowner_v1("randominvalidtoken.123456789", a_ch_id, b_data)
channel_removeowner_v1("token.12314511.token", a_ch_id, b_data)
channel_removeowner_v1(
"t817sn192w18HA&Dh8nq.J*(b98NQFASDA.(n(*@nq@dASDAN", a_ch_id,
b_data)
channel_removeowner_v1("COMP1531.COMP1531.COMP1531", a_ch_id, b_data)
def test_channel_add_remove_owner_v1(user_setup, channel_setup):
'''
#tests for the channel_addowner_v1 and channel_removeowner_v1
'''
# Test 1:
# Invite the third user to an empty public channel and then add/
# the second user as an owner
channel_leave_v1(make_token(1), 0) # peter leaves
channel_join_v2(make_token(2), 0) # chris joins
channel_invite_v2(make_token(2), 0, 1) # chris invites peter
channel_addowner_v1(make_token(2), 0, 1) # chris adds peter as an owner
assert channel_details_v2(make_token(1), 0) == {
'name': 'PublicChannel1',
'is_public': True,
'owner_members': [
{
'u_id': 2,
'email': '*****@*****.**',
'name_first': 'Christopher',
'name_last': 'Luong',
'handle': 'christopherluong',
},
{
'u_id': 1,
'email': '*****@*****.**',
'name_first': 'Peter',
'name_last': 'Tran',
'handle': 'petertran',
},
],
'all_members': [
{
'u_id': 2,
'email': '*****@*****.**',
'name_first': 'Christopher',
'name_last': 'Luong',
'handle': 'christopherluong',
},
{
'u_id': 1,
'email': '*****@*****.**',
'name_first': 'Peter',
'name_last': 'Tran',
'handle': 'petertran',
},
],
}
# Test 2:
# Add the first user into a public channel/
# make them the owner and remove the first owner from being the owner/
# check that the details are the same
channel_invite_v2(make_token(1), 1, 2)
channel_addowner_v1(make_token(1), 1, 2)
channel_removeowner_v1(make_token(2), 1, 1)
assert channel_details_v2(make_token(1), 1) == {
'name': 'PublicChannel2',
'is_public': True,
'owner_members': [
{
'u_id': 2,
'email': '*****@*****.**',
'name_first': 'Christopher',
'name_last': 'Luong',
'handle': 'christopherluong',
},
],
'all_members': [
{
'u_id': 1,
'email': '*****@*****.**',
'name_first': 'Peter',
'name_last': 'Tran',
'handle': 'petertran',
},
{
'u_id': 2,
'email': '*****@*****.**',
'name_first': 'Christopher',
'name_last': 'Luong',
'handle': 'christopherluong',
},
],
}
# Test 3:
# Add the first user into a private channel/
# make them the owner and remove the first owner from being the owner/
# check that the details are the same
channel_invite_v2(make_token(1), 4, 2)
channel_addowner_v1(make_token(1), 4, 2)
channel_removeowner_v1(make_token(2), 4, 1)
assert channel_details_v2(make_token(1), 4) == {
'name': 'PrivateChannel2',
'is_public': False,
'owner_members': [
{
'u_id': 2,
'email': '*****@*****.**',
'name_first': 'Christopher',
'name_last': 'Luong',
'handle': 'christopherluong',
},
],
'all_members': [
{
'u_id': 1,
'email': '*****@*****.**',
'name_first': 'Peter',
'name_last': 'Tran',
'handle': 'petertran',
},
{
'u_id': 2,
'email': '*****@*****.**',
'name_first': 'Christopher',
'name_last': 'Luong',
'handle': 'christopherluong',
},
],
}
def channel_removeowner():
data = request.get_json()
token = data["token"]
channel_id = data["channel_id"]
u_id = data["u_id"]
return dumps(channel_removeowner_v1(token, channel_id, u_id))
def test_all_invalid(create_input):
# token, channel_id, u_id do not exist,
# AccessError is prioritised
with pytest.raises(AccessError):
channel_removeowner_v1("anotherinvalidtoken", 321, 13)
def test_uid_invalid(create_input):
# u_id 20 does not exist
with pytest.raises(InputError):
channel_removeowner_v1(create_input[0][0]["token"],
create_input[1][0]["channel_id"], 20)
def test_remove_invalid_u_id(test_data):
_, a_data, _, c_data, a_ch_id, c_ch_id = test_data
with pytest.raises(InputError):
channel_removeowner_v1(a_data["token"], a_ch_id, "asdada")
channel_removeowner_v1(a_data["token"], a_ch_id, -999931313)
channel_removeowner_v1(a_data["token"], a_ch_id, 300303030)
channel_removeowner_v1(c_data["token"], c_ch_id, "^!@!$*!())))@")
channel_removeowner_v1(c_data["token"], c_ch_id, "XaEcA1873M~!$")
channel_removeowner_v1(c_data["token"], c_ch_id, 123654123)
def test_channel_id_invalid(create_input):
# channel_id 5 has not been created
with pytest.raises(InputError):
channel_removeowner_v1(create_input[0][0]["token"], 5,
create_input[0][1]["auth_user_id"])
