def test_channel_leave_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_leave_v1(result2['token'], channel1['channel_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'] == 0
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'] == 0
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'] == 1/2
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_invalid_channel(reg_user, create_channel):
clear_v2()
new_user = reg_user(0)
user_token = new_user['token']
user_id = new_user['auth_user_id']
channel_id = create_channel(user_token)['channel_id']
with pytest.raises(InputError):
channel_addowner_v1(user_token, channel_id + 1, user_id)
def test_invalid_token(reg_user, create_channel):
clear_v2()
new_user = reg_user(0)
user_id = new_user['auth_user_id']
user_token = new_user['token']
channel_id = create_channel(user_token)['channel_id']
with pytest.raises(AccessError):
channel_addowner_v1("invalid_token", channel_id, user_id)
def test_success_private_add(create_input):
# length of *_members for Fourth Channel before add
assert len(
channel_details_v2(
create_input[0][3]["token"],
create_input[1][3]["channel_id"])["owner_members"]) == 1
assert len(
channel_details_v2(
create_input[0][3]["token"],
create_input[1][3]["channel_id"])["all_members"]) == 1
assert channel_addowner_v1(create_input[0][3]["token"],
create_input[1][3]["channel_id"],
create_input[0][0]["auth_user_id"]) == {}
assert channel_addowner_v1(create_input[0][3]["token"],
create_input[1][3]["channel_id"],
create_input[0][1]["auth_user_id"]) == {}
# length of *_members for Fourth Channel after add; testing for all users
assert len(
channel_details_v2(
create_input[0][0]["token"],
create_input[1][3]["channel_id"])["owner_members"]) == 3
assert len(
channel_details_v2(
create_input[0][0]["token"],
create_input[1][3]["channel_id"])["all_members"]) == 3
assert len(
channel_details_v2(
create_input[0][1]["token"],
create_input[1][3]["channel_id"])["owner_members"]) == 3
assert len(
channel_details_v2(
create_input[0][1]["token"],
create_input[1][3]["channel_id"])["all_members"]) == 3
assert len(
channel_details_v2(
create_input[0][3]["token"],
create_input[1][3]["channel_id"])["owner_members"]) == 3
assert len(
channel_details_v2(
create_input[0][3]["token"],
create_input[1][3]["channel_id"])["all_members"]) == 3
with pytest.raises(AccessError):
channel_details_v2(create_input[0][4]["token"],
create_input[1][2]["channel_id"])["owner_members"]
channel_details_v2(create_input[0][4]["token"],
create_input[1][2]["channel_id"])["all_members"]
# number of channels each user is a part of
assert len(channels_list_v2(create_input[0][0]["token"])["channels"]) == 2
assert len(channels_list_v2(create_input[0][1]["token"])["channels"]) == 2
assert len(channels_list_v2(create_input[0][2]["token"])["channels"]) == 1
assert len(channels_list_v2(create_input[0][3]["token"])["channels"]) == 1
assert len(channels_list_v2(create_input[0][4]["token"])["channels"]) == 0
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_already_owner(reg_user, create_channel):
clear_v2()
first_user = reg_user(0)
second_user = reg_user(1)
first_token = first_user['token']
second_id = second_user['auth_user_id']
channel_id = create_channel(first_token)['channel_id']
channel_addowner_v1(first_token, channel_id, second_id)
with pytest.raises(InputError):
channel_addowner_v1(first_token, channel_id, second_id)
def test_channel_pin(test_data):
a_data, b_data, c_data = test_data
a_ch_id = channels_create_v2(a_data["token"], "A channel",
True)["channel_id"]
b_ch_id = channels_create_v2(b_data["token"], "B channel",
True)["channel_id"]
channel_join_v2(c_data["token"], a_ch_id)
channel_join_v2(c_data["token"], b_ch_id)
# pin own message
a1_msg_id = message_send_v2(a_data["token"], a_ch_id,
"My own message")["message_id"]
message_pin_v1(a_data["token"], a1_msg_id)
messages = channel_messages_v2(a_data["token"], a_ch_id, 0)["messages"]
# we know there is only one message sent, so it must be index 0 of messages
assert messages[0]["message_id"] == a1_msg_id
assert messages[0]["is_pinned"] == True
# pin someone elses message
c1_msg_id = message_send_v2(c_data["token"], a_ch_id,
"C's message")["message_id"]
message_pin_v1(a_data["token"], c1_msg_id)
messages = channel_messages_v2(a_data["token"], a_ch_id, 0)["messages"]
# channel_messages is most recent message first
assert messages[0]["message_id"] == c1_msg_id
assert messages[0]["is_pinned"] == True
# b_ch
b1_msg_id = message_send_v2(b_data["token"], b_ch_id,
"B's message whoo")["message_id"]
message_pin_v1(b_data["token"], b1_msg_id)
messages = channel_messages_v2(b_data["token"], b_ch_id, 0)["messages"]
assert messages[0]["message_id"] == b1_msg_id
assert messages[0]["is_pinned"] == True
channel_addowner_v1(b_data["token"], b_ch_id, c_data["auth_user_id"])
c2_msg_id = message_send_v2(c_data["token"], b_ch_id,
"C's second message whoo")["message_id"]
message_pin_v1(c_data["token"], c2_msg_id)
messages = channel_messages_v2(c_data["token"], b_ch_id, 0)["messages"]
assert messages[0]["message_id"] == c2_msg_id
assert messages[0]["is_pinned"] == True
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 test_fail_token_not_owner(create_input):
# length of *_members for Second Channel before add
assert len(
channel_details_v2(
create_input[0][1]["token"],
create_input[1][1]["channel_id"])["owner_members"]) == 1
assert len(
channel_details_v2(
create_input[0][1]["token"],
create_input[1][1]["channel_id"])["all_members"]) == 1
with pytest.raises(AccessError):
channel_addowner_v1(create_input[0][2]["token"],
create_input[1][1]["channel_id"],
create_input[0][3]["auth_user_id"])
def test_invite_global_owner(create_input):
""" Tests that when a global owner is invited to a channel, they will have
owner permissions in that channel.
"""
channel_1 = create_input[1][1]
assert channel_invite_v2(create_input[0][1]['token'],
channel_1['channel_id'],
create_input[0][0]['auth_user_id']) == {}
assert channel_invite_v2(create_input[0][1]['token'],
channel_1['channel_id'],
create_input[0][2]['auth_user_id']) == {}
# create_input[0][0] is a global owner, so when invited, they should join
# as a member but have owner permissions
# create_input[0][2] is a member
assert len(
channel_details_v2(create_input[0][1]['token'],
channel_1['channel_id'])['owner_members']) == 1
assert len(
channel_details_v2(create_input[0][1]['token'],
channel_1['channel_id'])['all_members']) == 3
# create_input[0][0] should be able to promote create_input[0][2] to a
# channel owner
assert channel_addowner_v1(create_input[0][0]['token'],
channel_1['channel_id'],
create_input[0][2]['auth_user_id']) == {}
def channel_addowner():
parameters = request.get_json()
token = parameters['token']
channel_id = parameters['channel_id']
u_id = parameters['u_id']
output = channel_addowner_v1(token, channel_id, u_id)
return dumps(output)
def test_success_owner_leave(create_input):
# Add another owner to First Channel
assert channel_addowner_v1(create_input[0][0]["token"], create_input[1][0]["channel_id"], create_input[0][4]["auth_user_id"]) == {}
# length of *_members for First Channel before leave
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"]) == 4
# One owner leaves
assert channel_leave_v1(create_input[0][0]["token"], create_input[1][0]["channel_id"]) == {}
# length of *_members for First Channel after leave; testing for all involved users
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"]) == 3
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"]) == 3
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"]) == 3
with pytest.raises(AccessError):
channel_details_v2(create_input[0][0]["token"], create_input[1][0]["channel_id"])
# number of channels each user is a part of
assert len(channels_list_v2(create_input[0][0]["token"])["channels"]) == 0
assert len(channels_list_v2(create_input[0][1]["token"])["channels"]) == 2
assert len(channels_list_v2(create_input[0][2]["token"])["channels"]) == 2
assert len(channels_list_v2(create_input[0][4]["token"])["channels"]) == 1
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_sender_non_channel_member(reg_user, create_channel):
clear_v2()
# first user is the owner of the **Dreams** as well as the owner of this channel, but the second user is neither of them
first_user = reg_user(0)
second_user = reg_user(1)
third_user = reg_user(2)
first_id = first_user['auth_user_id']
second_token = second_user['token']
third_token = third_user['token']
channel_id = create_channel(third_token)['channel_id']
with pytest.raises(AccessError):
channel_addowner_v1(second_token, channel_id, first_id)
def channel_addowner():
info = request.get_json()
token = info["token"]
channel_id = info["channel_id"]
u_id = info["u_id"]
channel_addowner = channel_addowner_v1(token, channel_id, u_id)
return dumps(channel_addowner)
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_already_unpinned(test_data):
a_data, b_data, c_data = test_data
a_ch_id = channels_create_v2(a_data["token"], "A channel", True)["channel_id"]
channel_join_v2(c_data["token"], a_ch_id)
channel_join_v2(b_data["token"], a_ch_id)
channel_addowner_v1(a_data["token"], a_ch_id, c_data["auth_user_id"])
channel_addowner_v1(a_data["token"], a_ch_id, b_data["auth_user_id"])
a1_msg_id = message_send_v2(a_data["token"], a_ch_id, "My own message")["message_id"]
message_pin_v1(a_data["token"], a1_msg_id)
message_unpin_v1(a_data["token"], a1_msg_id)
with pytest.raises(InputError):
message_unpin_v1(a_data["token"], a1_msg_id)
message_unpin_v1(b_data["token"], a1_msg_id)
message_unpin_v1(c_data["token"], a1_msg_id)
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_invalid_token(test_data):
_, _, b_data, _, a_ch_id, _ = test_data
with pytest.raises(AccessError):
channel_addowner_v1("randominvalidtoken.123456789", a_ch_id,
b_data["auth_user_id"])
channel_addowner_v1("token.12314511.token", a_ch_id,
b_data["auth_user_id"])
channel_addowner_v1(
"t817sn192w18HA&Dh8nq.J*(b98NQFASDA.(n(*@nq@dASDAN", a_ch_id,
b_data["auth_user_id"])
channel_addowner_v1("COMP1531.COMP1531.COMP1531", a_ch_id,
b_data["auth_user_id"])
def test_success_user_is_member(create_input):
# Add member to First Channel before making them owner
assert channel_join_v2(create_input[0][1]["token"],
create_input[1][0]["channel_id"]) == {}
assert channel_join_v2(create_input[0][2]["token"],
create_input[1][0]["channel_id"]) == {}
# length of *_members for First Channel before add
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"]) == 3
assert channel_addowner_v1(create_input[0][0]["token"],
create_input[1][0]["channel_id"],
create_input[0][1]["auth_user_id"]) == {}
# length of *_members for First Channel after add; testing for all users
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
assert len(
channel_details_v2(
create_input[0][1]["token"],
create_input[1][0]["channel_id"])["owner_members"]) == 2
assert len(
channel_details_v2(
create_input[0][1]["token"],
create_input[1][0]["channel_id"])["all_members"]) == 3
assert len(
channel_details_v2(
create_input[0][2]["token"],
create_input[1][0]["channel_id"])["owner_members"]) == 2
assert len(
channel_details_v2(
create_input[0][2]["token"],
create_input[1][0]["channel_id"])["all_members"]) == 3
# number of channels each user is a part of
assert len(channels_list_v2(create_input[0][0]["token"])["channels"]) == 1
assert len(channels_list_v2(create_input[0][1]["token"])["channels"]) == 2
assert len(channels_list_v2(create_input[0][2]["token"])["channels"]) == 2
assert len(channels_list_v2(create_input[0][3]["token"])["channels"]) == 1
assert len(channels_list_v2(create_input[0][4]["token"])["channels"]) == 0
def test_add_nonmember(test_data):
_, a_data, b_data, c_data, a_ch_id, c_ch_id = test_data
with pytest.raises(InputError):
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"])
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_mixed_harder():
clear_v1()
result1 = auth_register_v2('*****@*****.**', 'password', 'comp', 'student')
result2 = auth_register_v2('*****@*****.**', 'password', 'comp', 'student')
channel1 = channels_create_v2(result1['token'], "The party channel 1", True)['channel_id']
message_send_v2(result1['token'], channel1, 'hello how are you')
dm_create_v1(result1['token'], [result2['auth_user_id']])
output = user_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'] == 1
assert output['user_stats']['messages_sent'][-1]['num_messages_sent'] == 1
assert output['user_stats']['involvement_rate'] == 1
channels_create_v2(result1['token'], "The party channel 2", True)
channel3 = channels_create_v2(result2['token'], "The party channel 3", True)['channel_id']
channel_addowner_v1(result2['token'], channel3, result1['auth_user_id'])
message_send_v2(result2['token'], channel3, 'hello how are you')
output1 = user_stats(result1['token'])
output2 = user_stats(result2['token'])
assert len(output1['user_stats']) == 4
assert output1['user_stats']['channels_joined'][-1]['num_channels_joined'] == 3
assert output1['user_stats']['dms_joined'][-1]['num_dms_joined'] == 1
assert output1['user_stats']['messages_sent'][-1]['num_messages_sent'] == 1
assert output1['user_stats']['involvement_rate'] == 5/6
assert len(output2['user_stats']) == 4
assert output2['user_stats']['channels_joined'][-1]['num_channels_joined'] == 1
assert output2['user_stats']['dms_joined'][-1]['num_dms_joined'] == 1
assert output2['user_stats']['messages_sent'][-1]['num_messages_sent'] == 1
assert output2['user_stats']['involvement_rate'] == 3/6
dreams = users_stats(result1['token'])
assert len(dreams['dreams_stats']) == 4
assert dreams['dreams_stats']['channels_exist'][-1]['num_channels_exist'] == 3
assert dreams['dreams_stats']['dms_exist'][-1]['num_dms_exist'] == 1
assert dreams['dreams_stats']['messages_exist'][-1]['num_messages_exist'] == 2
assert dreams['dreams_stats']['utilization_rate'] == 1
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_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_success_owner_one_add(create_input):
# length of *_members for First Channel before add
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"]) == 1
assert channel_addowner_v1(create_input[0][0]["token"],
create_input[1][0]["channel_id"],
create_input[0][1]["auth_user_id"]) == {}
# length of *_members for First Channel after join; testing for both users
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"]) == 2
assert len(
channel_details_v2(
create_input[0][1]["token"],
create_input[1][0]["channel_id"])["owner_members"]) == 2
assert len(
channel_details_v2(
create_input[0][1]["token"],
create_input[1][0]["channel_id"])["all_members"]) == 2
# number of channels each user is a part of
assert len(channels_list_v2(create_input[0][0]["token"])["channels"]) == 1
assert len(channels_list_v2(create_input[0][1]["token"])["channels"]) == 2
def create_input():
clear_v1()
data_test_users = [
auth_register_v2("*****@*****.**", "validpassword", "Josh",
"Hatton"),
auth_register_v2("*****@*****.**", "anotherpassword", "Bunny",
"Dong"),
auth_register_v2("*****@*****.**", "password3", "Jordan",
"Milch"),
auth_register_v2("*****@*****.**", "4thpassword", "Dean",
"Zworestine"),
auth_register_v2("*****@*****.**", "finalpassword", "Eric",
"Zheng"),
]
data_test_channels = [
channels_create_v2(data_test_users[0]["token"], "First Channel", True),
channels_create_v2(data_test_users[1]["token"], "Second Channel",
True),
channels_create_v2(data_test_users[2]["token"], "Third Channel", True),
channels_create_v2(data_test_users[3]["token"], "Fourth Channel",
False),
]
channel_addowner_v1(data_test_users[0]["token"],
data_test_channels[0]["channel_id"],
data_test_users[1]["auth_user_id"])
channel_addowner_v1(data_test_users[1]["token"],
data_test_channels[1]["channel_id"],
data_test_users[0]["auth_user_id"])
channel_addowner_v1(data_test_users[2]["token"],
data_test_channels[2]["channel_id"],
data_test_users[3]["auth_user_id"])
channel_join_v2(data_test_users[4]["token"],
data_test_channels[0]["channel_id"])
return [data_test_users, data_test_channels]
def test_dreams_owner(test_data):
# stub until dreams implementation
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 a
owners
a
members
a, b, c, g.o
channel c
owners
c
members
c, a, b, g.o
"""
assert channel_addowner_v1(global_owner["token"], a_ch_id,
b_data["auth_user_id"]) == {}
assert channel_addowner_v1(global_owner["token"], a_ch_id,
c_data["auth_user_id"]) == {}
assert channel_addowner_v1(global_owner["token"], a_ch_id,
global_owner["auth_user_id"]) == {}
assert channel_addowner_v1(global_owner["token"], c_ch_id,
a_data["auth_user_id"]) == {}
assert channel_addowner_v1(global_owner["token"], c_ch_id,
b_data["auth_user_id"]) == {}
assert channel_addowner_v1(global_owner["token"], c_ch_id,
global_owner["auth_user_id"]) == {}
def test_channel(test_data):
a_data, b_data, c_data = test_data
# a creates a channel
# a involvement should be 1 (only channel)
# b involvement should be 0
a_ch_timestamp = datetime.now().replace(microsecond=0).timestamp()
channels_create_v2(a_data["token"], "A channel", True)
sleep(1)
user_stats = user_stats_v1(a_data["token"])["user_stats"]
# going to skip 0, as that is the init timestamp
assert user_stats["channels_joined"][1]["num_channels_joined"] == 1
assert abs(user_stats["channels_joined"][1]["time_stamp"] - a_ch_timestamp) <= 1
assert user_stats["involvement_rate"] == 1
user_stats = user_stats_v1(b_data["token"])["user_stats"]
assert user_stats["channels_joined"][0]["num_channels_joined"] == 0
assert abs(user_stats["channels_joined"][0]["time_stamp"] - b_data["time_registered"]) <= 1
# b creates a channel
# a and b should have the same involvement rate now (2 channels, each in different channels)
b_ch_timestamp = datetime.now().replace(microsecond=0).timestamp()
b_ch_id = channels_create_v2(b_data["token"], "B channel", True)["channel_id"]
sleep(1)
user_stats = user_stats_v1(b_data["token"])["user_stats"]
assert user_stats["channels_joined"][1]["num_channels_joined"] == 1
assert abs(user_stats["channels_joined"][1]["time_stamp"] - b_ch_timestamp) <= 1
assert user_stats["involvement_rate"] == 0.5
user_stats = user_stats_v1(a_data["token"])["user_stats"]
assert user_stats["channels_joined"][1]["num_channels_joined"] == 1
assert abs(user_stats["channels_joined"][1]["time_stamp"] - a_ch_timestamp) <= 1
assert user_stats["involvement_rate"] == 0.5
# b creates a second channel
# b is now in 2/3 channels
# a is in only 1/3 channels
b2_ch_timestamp = datetime.now().replace(microsecond=0).timestamp()
channels_create_v2(b_data["token"], "B2 channel", True)["channel_id"]
sleep(1)
user_stats = user_stats_v1(b_data["token"])["user_stats"]
assert user_stats["channels_joined"][1]["num_channels_joined"] == 1
assert abs(user_stats["channels_joined"][1]["time_stamp"] - b_ch_timestamp) <= 1
assert user_stats["channels_joined"][2]["num_channels_joined"] == 2
assert abs(user_stats["channels_joined"][2]["time_stamp"] - b2_ch_timestamp) <= 1
assert user_stats["involvement_rate"] == 0.67
user_stats = user_stats_v1(a_data["token"])["user_stats"]
assert user_stats["channels_joined"][1]["num_channels_joined"] == 1
assert abs(user_stats["channels_joined"][1]["time_stamp"] - a_ch_timestamp) <= 1
assert user_stats["involvement_rate"] == 0.33
c_ch_join_timestamp = datetime.now().replace(microsecond=0).timestamp()
channel_join_v2(c_data["token"], b_ch_id)
channel_addowner_v1(b_data["token"], b_ch_id, c_data["auth_user_id"])
sleep(1)
# b leaves one of his channels
# a, b c are now in 1/3 existing channels
b_ch_leave_timestamp = datetime.now().replace(microsecond=0).timestamp()
channel_leave_v1(b_data["token"], b_ch_id)
sleep(1)
user_stats = user_stats_v1(a_data["token"])["user_stats"]
assert user_stats["channels_joined"][1]["num_channels_joined"] == 1
assert abs(user_stats["channels_joined"][1]["time_stamp"] - a_ch_timestamp) <= 1
assert user_stats["involvement_rate"] == 0.33
user_stats = user_stats_v1(b_data["token"])["user_stats"]
assert user_stats["channels_joined"][1]["num_channels_joined"] == 1
assert abs(user_stats["channels_joined"][1]["time_stamp"] - b_ch_timestamp) <= 1
assert user_stats["channels_joined"][2]["num_channels_joined"] == 2
assert abs(user_stats["channels_joined"][2]["time_stamp"] - b2_ch_timestamp) <= 1
assert user_stats["channels_joined"][3]["num_channels_joined"] == 1
assert abs(user_stats["channels_joined"][3]["time_stamp"] - b_ch_leave_timestamp) <= 1
assert user_stats["involvement_rate"] == 0.33
user_stats = user_stats_v1(c_data["token"])["user_stats"]
assert user_stats["channels_joined"][1]["num_channels_joined"] == 1
assert abs(user_stats["channels_joined"][1]["time_stamp"] - c_ch_join_timestamp) <= 1
assert user_stats["involvement_rate"] == 0.33
