def test_fail_not_member(create_input):
# 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"]) == 1
assert len(channel_details_v2(create_input[0][0]["token"], create_input[1][0]["channel_id"])["all_members"]) == 3
with pytest.raises(AccessError):
channel_leave_v1(create_input[0][4]["token"], create_input[1][0]["channel_id"])
def test_channel_leave_invalid_channel_id():
# Test if InputError is raised when given invalid channel id
clear_v1()
user = auth_register_v2('*****@*****.**', 'password123', 'Terry', 'Wills')
channels_create_v2(user['token'], 'Example Channel', True)
with pytest.raises(InputError):
channel_leave_v1(user['token'], -1)
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_leave_invalid_token():
# Test if AccessError is raised when given invalid token
clear_v1()
user = auth_register_v2('*****@*****.**', 'password1234', 'Harry', 'Lurr')
channel = channels_create_v2(user['token'], 'Example Channel', True)
with pytest.raises(AccessError):
channel_leave_v1('auisdb2ubg432u3b2i3b', channel['channel_id'])
def test_channel_leave_v1_auth_user_not_member_of_channel(reg_user, basic_channel_name):
clear_v2()
token_1 = reg_user(0)['token'] #use v2 because we want tokens as well
token_2 = reg_user(1)['token']
channel_name = basic_channel_name
channel_id = channels_create_v2(token_1, channel_name, True)['channel_id']
with pytest.raises(AccessError):
channel_leave_v1(token_2, channel_id) #user never joined the channel so cant leave a channel you are not in
def test_channel_leave_v1_non_valid_channel_id(reg_user, basic_channel_name):
clear_v2()
token_1 = reg_user(0)['token'] #use v2 because we want tokens as well
token_2 = reg_user(1)['token']
channel_name = basic_channel_name
fake_channel_id = 'random values sdasdsadsadsawer'
channel_id = channels_create_v2(token_1, channel_name, True)['channel_id']
channel_join_v2(token_2, channel_id) #user is able to join a real channel
with pytest.raises(InputError):
channel_leave_v1(token_2, fake_channel_id) #channel does not exist cant leave it
def test_channel_leave_v1_token(reg_user, basic_channel_name):
clear_v2()
token_1 = reg_user(0)['token'] #use v2 because we want tokens as well
token_2 = reg_user(1)['token']
channel_name = basic_channel_name
fake_token = 'random values'
channel_id = channels_create_v2(token_1, channel_name, True)['channel_id']
channel_join_v2(token_2, channel_id)
with pytest.raises(AccessError):
channel_leave_v1(fake_token, channel_id)
def test_channel_leave_valid_case():
# Tests channel leave is successful by checking channels_list for that user
clear_v1()
user = auth_register_v2('*****@*****.**', 'password2323', 'Antonio',
'Suarez')
channel = channels_create_v2(user['token'], 'Antonios Server', True)
channel_leave_v1(user['token'], channel['channel_id'])
# Call channel_list to check if user is not member of channel anymore
joined_channels_of_user = channels_list_v2(user['token'])
# List should be empty with user not joined any channels
assert joined_channels_of_user['channels'] == []
def test_channel_leave_user_not_member():
# Test if AccessError is raised when user tries to leave a group
# that they are not a member of
clear_v1()
user_creator = auth_register_v2('*****@*****.**', 'password2321', 'Irwin',
'Dundee')
channel = channels_create_v2(user_creator['token'], 'Irwins Channel', True)
random_leaver = auth_register_v2('*****@*****.**', 'password2', 'Irvine',
'Dundle')
with pytest.raises(AccessError):
channel_leave_v1(random_leaver['token'], channel['channel_id'])
def test_channel_owner_leave(reg_user, basic_channel_name):
clear_v2()
user_1 = reg_user(0)
token_1 = user_1['token']
id_1 = user_1['auth_user_id']
token_2 = reg_user(1)['token']
channel_name = basic_channel_name
channel_id = channels_create_v2(token_1, channel_name, True)['channel_id']
channel_join_v2(token_2, channel_id)
channel_leave_v1(token_1, channel_id)
channel_details = channel_details_v2(token_2, channel_id)
assert id_1 not in channel_details['all_members'] # Verify that owner has left channel
assert id_1 not in channel_details['owner_members']
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 channel_leave():
info = request.get_json()
token = info["token"]
channel_id = info["channel_id"]
channel_leave = channel_leave_v1(token, channel_id)
return dumps(channel_leave)
def test_leaved_user_is_not_a_member(reg_user, basic_channel_name):
clear_v2()
token_1 = reg_user(0)['token'] #use v2 because we want tokens as well
user_register2 = reg_user(1)
channel_name = basic_channel_name
channel_id = channels_create_v2(token_1, channel_name, True)['channel_id']
channel_join_v2(user_register2['token'], channel_id)
channel_details = channel_details_v2(token_1, channel_id)
check_joined = False
for members in channel_details['all_members']:
if user_register2['auth_user_id'] == members['u_id']: # Verify that joined user is apart of the channel
check_joined = True
assert check_joined == True
channel_leave_v1(user_register2['token'], channel_id)
channel_details = channel_details_v2(token_1, channel_id) #this was the issue its in the wrong order
for members in channel_details['all_members']:
assert user_register2['auth_user_id'] != members['u_id']
def test_mixed_decrement():
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']
message1 = message_send_v2(result1['token'], channel1, 'hello how are you')['message_id']
message_remove_v1(result1['token'], message1)
channel_join_v2(result2['token'], channel1)
channel_leave_v1(result2['token'], channel1)
output = user_stats(result1['token'])
assert output['user_stats']['channels_joined'][-1]['num_channels_joined'] == 1
assert output['user_stats']['messages_sent'][-1]['num_messages_sent'] == 1
output1 = user_stats(result2['token'])
assert output1['user_stats']['channels_joined'][-1]['num_channels_joined'] == 0
dreams = users_stats(result1['token'])
assert dreams['dreams_stats']['channels_exist'][-1]['num_channels_exist'] == 1
assert dreams['dreams_stats']['messages_exist'][-1]['num_messages_exist'] == 0
def test_success_multiple_leave(create_input):
# 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"]) == 1
assert len(channel_details_v2(create_input[0][0]["token"], create_input[1][0]["channel_id"])["all_members"]) == 3
assert channel_leave_v1(create_input[0][1]["token"], create_input[1][0]["channel_id"]) == {}
assert channel_leave_v1(create_input[0][2]["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][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
with pytest.raises(AccessError):
channel_details_v2(create_input[0][1]["token"], create_input[1][0]["channel_id"])
channel_details_v2(create_input[0][2]["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"]) == 1
assert len(channels_list_v2(create_input[0][1]["token"])["channels"]) == 1
assert len(channels_list_v2(create_input[0][2]["token"])["channels"]) == 1
def test_message_unreact_user_not_member():
# Authorised user is not a member of the channel or DM the message exists in
clear_v1()
user = auth_register_v2("*****@*****.**", "password", "bob", "williams")
user2 = auth_register_v2("*****@*****.**", "password", "billy",
"williams")
channel = channels_create_v2(user['token'], 'channel example', True)
channel_join_v2(user2['token'], channel['channel_id'])
msg = message_send_v2(user["token"], channel['channel_id'], 'helo world')
message_react_v1(user2['token'], msg["message_id"], 1)
# User leaves channel so cannot unreact
channel_leave_v1(user2['token'], channel['channel_id'])
with pytest.raises(AccessError):
message_unreact_v1(user2['token'], msg["message_id"], 1)
dm = dm_create_v1(user['token'], [user2["auth_user_id"]])
msg = message_senddm_v1(user["token"], dm["dm_id"], "hi hi")
message_react_v1(user2['token'], msg["message_id"], 1)
dm_leave_v1(user2["token"], dm["dm_id"])
with pytest.raises(AccessError):
message_unreact_v1(user2["token"], msg["message_id"], 1)
def test_channel_join_leave_errors(user_setup, channel_setup):
'''
#test the errors for channel_join_v2 and channel_leave_v2
'''
# Test 6:
# invalid authorised user
with pytest.raises(AccessError):
channel_join_v2(make_token(10), 2)
# Test 7:
# invalid channel id
with pytest.raises(InputError):
channel_join_v2(make_token(1), 10)
# Test 8:
# channel_id refers to a private channel
with pytest.raises(AccessError):
channel_join_v2(make_token(2), 5)
# Test 6:
# invalid authorised user
with pytest.raises(AccessError):
channel_leave_v1(make_token(10), 2)
# Test 7:
# invalid channel id
with pytest.raises(InputError):
channel_leave_v1(make_token(1), 10)
# Test 8:
# channel_id refers to a private channel and the authorised user is not a member
with pytest.raises(AccessError):
channel_leave_v1(make_token(2), 5)
def channel_leave():
data = request.get_json()
token = data["token"]
channel_id = data["channel_id"]
return dumps(channel_leave_v1(token, channel_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
def test_channel_join_leave_v2(user_setup, channel_setup):
#test that channel_join_v2 and channel_leave_v1 are working correctly
# Test 1:
# the 3rd user joins a public channel and then make sure the details/
# are correct
channel_join_v2(make_token(2), 0)
assert channel_details_v2(make_token(2), 0) == {
'name': 'PublicChannel1',
'is_public': True,
'owner_members': [
{
'u_id': 1,
'email': '*****@*****.**',
'name_first': 'Peter',
'name_last': 'Tran',
'handle': 'petertran',
},
],
'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 2:
# joining the dream owner into the channel
channel_join_v2(make_token(0), 0)
assert channel_details_v2(make_token(1), 0) == {
'name': 'PublicChannel1',
'is_public': True,
'owner_members': [
{
'u_id': 1,
'email': '*****@*****.**',
'name_first': 'Peter',
'name_last': 'Tran',
'handle': 'petertran',
},
{
'u_id': 0,
'email': '*****@*****.**',
'name_first': 'Gungeet',
'name_last': 'Singh',
'handle': 'gungeetsingh',
},
],
'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',
},
{
'u_id': 0,
'email': '*****@*****.**',
'name_first': 'Gungeet',
'name_last': 'Singh',
'handle': 'gungeetsingh',
},
],
}
# Test 3:
# the first and second user leaves and rejoins and then/
# make sure the details are correct once again
assert channel_leave_v1(make_token(0), 0) == {}
assert channel_leave_v1(make_token(1), 0) == {}
assert channel_join_v2(make_token(0), 0) == {}
assert channel_join_v2(make_token(1), 0) == {}
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': 0,
'email': '*****@*****.**',
'name_first': 'Gungeet',
'name_last': 'Singh',
'handle': 'gungeetsingh',
},
],
'all_members': [
{
'u_id': 2,
'email': '*****@*****.**',
'name_first': 'Christopher',
'name_last': 'Luong',
'handle': 'christopherluong',
},
{
'u_id': 0,
'email': '*****@*****.**',
'name_first': 'Gungeet',
'name_last': 'Singh',
'handle': 'gungeetsingh',
},
{
'u_id': 1,
'email': '*****@*****.**',
'name_first': 'Peter',
'name_last': 'Tran',
'handle': 'petertran',
},
],
}
# Test 4:
# the 1st and 3rd users are invited to a private channel/
# then the 1st and 2nd users leave/
# and make sure the details are correct
# essentially owner leaves and last user becomes the owner
assert channel_invite_v2(make_token(1), 3, 0) == {}
assert channel_invite_v2(make_token(1), 3, 2) == {}
assert channel_leave_v1(make_token(0), 3) == {}
assert channel_leave_v1(make_token(1), 3) == {}
assert channel_details_v2(make_token(2), 3) == {
'name': 'PrivateChannel1',
'is_public': False,
'owner_members': [
{
'u_id': 2,
'email': '*****@*****.**',
'name_first': 'Christopher',
'name_last': 'Luong',
'handle': 'christopherluong',
},
],
'all_members': [
{
'u_id': 2,
'email': '*****@*****.**',
'name_first': 'Christopher',
'name_last': 'Luong',
'handle': 'christopherluong',
},
],
}
# Test 5:
# owner leaves a public channel and 3rd user joins/
# then make sure details are correct
assert channel_leave_v1(make_token(1), 2) == {}
assert channel_join_v2(make_token(2), 2) == {}
assert channel_details_v2(make_token(2), 2) == {
'name': 'PublicChannel3',
'is_public': True,
'owner_members': [
{
'u_id': 2,
'email': '*****@*****.**',
'name_first': 'Christopher',
'name_last': 'Luong',
'handle': 'christopherluong',
},
],
'all_members': [
{
'u_id': 2,
'email': '*****@*****.**',
'name_first': 'Christopher',
'name_last': 'Luong',
'handle': 'christopherluong',
},
],
}
def test_user_stats_channels(register_users, channel_setup):
# test channels
assert user_stats_v1(make_token(0)) == {
'user_stats': {
"channels_joined": [{
"num_channels_joined": 0,
"time_stamp": str(create_timestamp())
}, {
"num_channels_joined": 1,
"time_stamp": str(create_timestamp())
}, {
"num_channels_joined": 2,
"time_stamp": str(create_timestamp())
}, {
"num_channels_joined": 3,
"time_stamp": str(create_timestamp())
}],
"dms_joined": [{
"num_dms_joined": 0,
"time_stamp": str(create_timestamp())
}],
"messages_sent": [{
"num_messages_sent": 0,
"time_stamp": str(create_timestamp())
}],
"involvement_rate":
1.0
}
}
channel_invite_v2(make_token(0), 0, 1)
assert user_stats_v1(make_token(1)) == {
'user_stats': {
"channels_joined": [
{
"num_channels_joined": 0,
"time_stamp": str(create_timestamp())
},
{
"num_channels_joined": 1,
"time_stamp": str(create_timestamp())
},
],
"dms_joined": [{
"num_dms_joined": 0,
"time_stamp": str(create_timestamp())
}],
"messages_sent": [{
"num_messages_sent": 0,
"time_stamp": str(create_timestamp())
}],
"involvement_rate":
0.33
}
}
channel_leave_v1(make_token(1), 0)
assert user_stats_v1(make_token(1)) == {
'user_stats': {
"channels_joined": [{
"num_channels_joined": 0,
"time_stamp": str(create_timestamp())
}, {
"num_channels_joined": 1,
"time_stamp": str(create_timestamp())
}, {
"num_channels_joined": 0,
"time_stamp": str(create_timestamp())
}],
"dms_joined": [{
"num_dms_joined": 0,
"time_stamp": str(create_timestamp())
}],
"messages_sent": [{
"num_messages_sent": 0,
"time_stamp": str(create_timestamp())
}],
"involvement_rate":
0.0
}
}
channel_join_v2(make_token(2), 0)
assert user_stats_v1(make_token(2)) == {
'user_stats': {
"channels_joined": [{
"num_channels_joined": 0,
"time_stamp": str(create_timestamp())
}, {
"num_channels_joined": 1,
"time_stamp": str(create_timestamp())
}],
"dms_joined": [{
"num_dms_joined": 0,
"time_stamp": str(create_timestamp())
}],
"messages_sent": [{
"num_messages_sent": 0,
"time_stamp": str(create_timestamp())
}],
"involvement_rate":
0.33
}
}
def test_both_invalid(create_input):
# token, channel_id do not exist,
# AccessError is prioritised
with pytest.raises(AccessError):
channel_leave_v1('insertanotherinvalidtokenhere', 321)
def test_token_invalid(create_input):
# token does not exist
with pytest.raises(AccessError):
channel_leave_v1('insertinvalidtokenhere', create_input[1][0]["channel_id"])
def test_channel_id_invalid(create_input):
# channel_id 5 has not been created
with pytest.raises(InputError):
channel_leave_v1(create_input[0][0]["token"], 5)
def test_channel_messages_v2(user_setup, channel_setup):
'''
#Tests for channel_messages_v2
'''
# Test 1:
# send a message to a public channel and check the message exists
message_send_v2(make_token(1), 0, "onions can be eaten raw")
dateTimeObj = datetime.now()
timeStampStr = dateTimeObj.strftime("%d-%b-%Y (%H:%M)")
assert channel_messages_v2(make_token(1), 0, 0) == {
"messages": [
{
"message_id": 0,
"u_id": 1,
"message": "onions can be eaten raw",
"time_created": timeStampStr,
"channel_id": 0,
"dm_id": -1,
'reacts': [
{
'react_id': 1,
'u_ids': [],
'is_this_user_reacted': False
}
],
'is_pinned': False
},
],
"start": 0,
"end": -1,
}
# Test 2:
# check the messages in a fresh public channel
assert channel_messages_v2(make_token(1), 1, 0) == {
"messages": [],
"start": 0,
"end": -1,
}
# Test 3:
# add a user to a public channel and they send a message
# check the messages sent in a public channel/
# after the user leaves the channel
channel_invite_v2(make_token(1), 1, 0)
message_send_v2(make_token(0), 1, "onions cannot be eaten raw")
dateTimeObj = datetime.now()
timeStampStr = dateTimeObj.strftime("%d-%b-%Y (%H:%M)")
channel_leave_v1(make_token(0), 1)
assert channel_messages_v2(make_token(1), 1, 0) == {
"messages": [
{
"message_id": 1,
"u_id": 0,
"message": "onions cannot be eaten raw",
"time_created": timeStampStr,
"channel_id": 1,
"dm_id": -1,
'reacts': [
{
'react_id': 1,
'u_ids': [],
'is_this_user_reacted': False
}
],
'is_pinned': False
},
],
"start": 0,
"end": -1,
}
# Test 4:
# invite the first and third user to join a public channel
# everyone sends an identical message from the first to the third user/
# and check the messages in the channel
channel_invite_v2(make_token(1), 2, 0)
channel_invite_v2(make_token(1), 2, 2)
timeStampStr = []
message_send_v2(make_token(0), 2, "wait until you try raw radishes")
dateTimeObj = datetime.now()
timeStampStr.append(dateTimeObj.strftime("%d-%b-%Y (%H:%M)"))
message_send_v2(make_token(1), 2, "wait until you try raw radishes")
dateTimeObj = datetime.now()
timeStampStr.append(dateTimeObj.strftime("%d-%b-%Y (%H:%M)"))
message_send_v2(make_token(2), 2, "wait until you try raw radishes")
dateTimeObj = datetime.now()
timeStampStr.append(dateTimeObj.strftime("%d-%b-%Y (%H:%M)"))
assert channel_messages_v2(make_token(1), 2, 0) == {
"messages": [
{
"message_id": 4,
"u_id": 2,
"message": "wait until you try raw radishes",
"time_created": timeStampStr[2],
"channel_id": 2,
"dm_id": -1,
'reacts': [
{
'react_id': 1,
'u_ids': [],
'is_this_user_reacted': False
}
],
'is_pinned': False
},
{
"message_id": 3,
"u_id": 1,
"message": "wait until you try raw radishes",
"time_created": timeStampStr[1],
"channel_id": 2,
"dm_id": -1,
'reacts': [
{
'react_id': 1,
'u_ids': [],
'is_this_user_reacted': False
}
],
'is_pinned': False
},
{
"message_id": 2,
"u_id": 0,
"message": "wait until you try raw radishes",
"time_created": timeStampStr[0],
"channel_id": 2,
"dm_id": -1,
'reacts': [
{
'react_id': 1,
'u_ids': [],
'is_this_user_reacted': False
}
],
'is_pinned': False
},
],
"start": 0,
"end": -1,
}
# Test 5:
# send a message to a private channel and check the message exists
message_send_v2(make_token(1), 3, "onions can be eaten raw")
dateTimeObj = datetime.now()
timeStampStr = dateTimeObj.strftime("%d-%b-%Y (%H:%M)")
assert channel_messages_v2(make_token(1), 3, 0) == {
"messages": [
{
"message_id": 5,
"u_id": 1,
"message": "onions can be eaten raw",
"time_created": timeStampStr,
"channel_id": 3,
"dm_id": -1,
'reacts': [
{
'react_id': 1,
'u_ids': [],
'is_this_user_reacted': False
}
],
'is_pinned': False
},
],
"start": 0,
"end": -1,
}
# Test 6:
# check the messages in a fresh private channel
assert channel_messages_v2(make_token(1), 4, 0) == {
"messages": [],
"start": 0,
"end": -1,
}
# Test 7:
# add a user to a private channel and they send a message
# check the messages sent in a private channel/
# after the user leaves the channel
channel_invite_v2(make_token(1), 4, 0)
message_send_v2(make_token(0), 4, "onions cannot be eaten raw")
dateTimeObj = datetime.now()
timeStampStr = dateTimeObj.strftime("%d-%b-%Y (%H:%M)")
channel_leave_v1(make_token(0), 4)
assert channel_messages_v2(make_token(1), 4, 0) == {
"messages": [
{
"message_id": 6,
"u_id": 0,
"message": "onions cannot be eaten raw",
"time_created": timeStampStr,
"channel_id": 4,
"dm_id": -1,
'reacts': [
{
'react_id': 1,
'u_ids': [],
'is_this_user_reacted': False
}
],
'is_pinned': False
},
],
"start": 0,
"end": -1,
}
# Test 8:
# invite the first and third user to join a public channel
# everyone sends an identical message from the first to the third user/
# and check the messages in the channel
channel_invite_v2(make_token(1), 5, 0)
channel_invite_v2(make_token(1), 5, 2)
timeStampStr = []
message_send_v2(make_token(0), 5, "wait until you try raw radishes")
dateTimeObj = datetime.now()
timeStampStr.append(dateTimeObj.strftime("%d-%b-%Y (%H:%M)"))
message_send_v2(make_token(1), 5, "wait until you try raw radishes")
dateTimeObj = datetime.now()
timeStampStr.append(dateTimeObj.strftime("%d-%b-%Y (%H:%M)"))
message_send_v2(make_token(2), 5, "wait until you try raw radishes")
dateTimeObj = datetime.now()
timeStampStr.append(dateTimeObj.strftime("%d-%b-%Y (%H:%M)"))
assert channel_messages_v2(make_token(1), 5, 0) == {
"messages": [
{
"message_id": 9,
"u_id": 2,
"message": "wait until you try raw radishes",
"time_created": timeStampStr[2],
"channel_id": 5,
"dm_id": -1,
'reacts': [
{
'react_id': 1,
'u_ids': [],
'is_this_user_reacted': False
}
],
'is_pinned': False
},
{
"message_id": 8,
"u_id": 1,
"message": "wait until you try raw radishes",
"time_created": timeStampStr[1],
"channel_id": 5,
"dm_id": -1,
'reacts': [
{
'react_id': 1,
'u_ids': [],
'is_this_user_reacted': False
}
],
'is_pinned': False
},
{
"message_id": 7,
"u_id": 0,
"message": "wait until you try raw radishes",
"time_created": timeStampStr[0],
"channel_id": 5,
"dm_id": -1,
'reacts': [
{
'react_id': 1,
'u_ids': [],
'is_this_user_reacted': False
}
],
'is_pinned': False
},
],
"start": 0,
"end": -1,
}
def channel_leave():
parameters = request.get_json()
token = parameters['token']
channel_id = parameters['channel_id']
output = channel_leave_v1(token, channel_id)
return dumps(output)
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',
},
],
}
