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_channels_listall_v2_invalid_user(user_setup):
'''
Invalid user attempts to call channels listall
'''
channels_create_v2(make_token(1), 'PChannel1', True)
with pytest.raises(AccessError):
channels_list_v2(make_token(1000))
def test_success_one_join(create_input):
# length of *_members for First Channel before join
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_join_v2(create_input[0][1]["token"],
create_input[1][0]["channel_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"]) == 1
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"]) == 1
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 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_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_non_member_single_channel():
clear_v1()
user_1 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a')
user_2 = auth_register_v2('*****@*****.**', 'bbbbbb', 'b', 'b')
channel_1 = channels_create_v2(user_1['token'], 'Channel 1', True)
assert channels_list_v2(user_2['token']) == {'channels': []}
assert channels_list_v2(user_1['token']) == {
'channels': [{
'channel_id': channel_1['channel_id'],
'name': 'Channel 1'
}]
}
clear_v1()
def test_user_not_in_channel(reg_user):
clear_v2()
auth_user_token = reg_user(0)['token']
channel_list = channels_list_v2(auth_user_token)['channels']
assert len(channel_list) == 0
def test_mix_channels():
clear_v1()
user_1 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a')
user_2 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a')
channel_1 = channels_create_v2(user_1['token'], 'Channel 1', True)
channel_2 = channels_create_v2(user_1['token'], 'Channel 2', True)
channel_3 = channels_create_v2(user_1['token'], 'Channel 3', False)
channel_4 = channels_create_v2(user_1['token'], 'Channel 4', False)
channel_5 = channels_create_v2(user_1['token'], 'Channel 5', True)
channel_invite_v2(user_1['token'], channel_1['channel_id'],
user_2['auth_user_id'])
channel_invite_v2(user_1['token'], channel_3['channel_id'],
user_2['auth_user_id'])
channel_invite_v2(user_1['token'], channel_5['channel_id'],
user_2['auth_user_id'])
assert channels_list_v2(user_1['token']) == {
'channels': [{
'channel_id': channel_1['channel_id'],
'name': 'Channel 1'
}, {
'channel_id': channel_2['channel_id'],
'name': 'Channel 2'
}, {
'channel_id': channel_3['channel_id'],
'name': 'Channel 3'
}, {
'channel_id': channel_4['channel_id'],
'name': 'Channel 4'
}, {
'channel_id': channel_5['channel_id'],
'name': 'Channel 5'
}]
}
assert channels_list_v2(user_2['token']) == {
'channels': [{
'channel_id': channel_1['channel_id'],
'name': 'Channel 1'
}, {
'channel_id': channel_3['channel_id'],
'name': 'Channel 3'
}, {
'channel_id': channel_5['channel_id'],
'name': 'Channel 5'
}]
}
clear_v1()
def test_successful_remove(create_input):
user_1, user_2, user_3, user_4, user_5 = create_input[0]
assert admin_user_remove_v1(user_1["token"], user_2["auth_user_id"]) == {}
assert admin_user_remove_v1(user_1["token"], user_3["auth_user_id"]) == {}
assert admin_user_remove_v1(user_1["token"], user_4["auth_user_id"]) == {}
assert admin_user_remove_v1(user_1["token"], user_5["auth_user_id"]) == {}
# check to see that these users are indeed removed
# only user_1 should be shown when calling users_all
assert users_all_v1(user_1["token"]) == {
"users":
[user_profile_v2(user_1["token"], user_1["auth_user_id"])["user"]]
}
# calling channels list should raise an input error as their u_id's are invalid
with pytest.raises(AccessError):
channels_list_v2(user_2["token"])
channels_list_v2(user_3["token"])
channels_list_v2(user_4["token"])
channels_list_v2(user_5["token"])
# Check to see each removed user's profile is retrievable and their name is
# now 'Removed user'
for user in [user_2, user_3, user_4, user_5]:
user_profile = user_profile_v2(user_1["token"], user["auth_user_id"])
assert type(user_profile) == dict
assert (
f"{user_profile['user']['name_first']}{user_profile['user']['name_last']}"
== "Removed user" or
f"{user_profile['user']['name_first']} {user_profile['user']['name_last']}"
== "Removed user")
# CHECK THAT MESSAGES SENT ARE 'REMOVED USER'
# check channel messages for user 2
channel_join_v2(user_1["token"], create_input[1][1]["channel_id"])
channel_1_messages = channel_messages_v2(user_1["token"],
create_input[1][1]["channel_id"],
0)
for message in channel_1_messages["messages"]:
if message["message_id"] == create_input[2][1]:
assert message["message"] == "Removed user"
# check channel messages for user 3
channel_join_v2(user_1["token"], create_input[1][0]["channel_id"])
channel_2_messages = channel_messages_v2(user_1["token"],
create_input[1][0]["channel_id"],
0)
for message in channel_2_messages["messages"]:
if message["message_id"] == create_input[2][2]:
assert message["message"] == "Removed user"
clear_v1()
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 search_v2(token, query_str):
""" Given a query string, return a collection of messages in
all the channels/DMs that the authorised user has joined
that match the query
Arguments:
token (string) - token of authenticated user
query_str (string) - string to be searched for
Exceptions:
InputError - Occurs when query_str is above 1000 characters
- Occurs when query_str is empty
AccessError - Occurs when token is invalid
Return value:
{
messages - List of dictionaries,
where each dictionary contains types:
{message_id, u_id, message, time_created}
}
"""
# Check validity of token
findUser(token)
# Check query_str is less than 1000 characters or not empty
if len(query_str) > 1000:
raise InputError(description="query string can't be over 1000 characters")
if len(query_str) == 0:
raise InputError(description="query string can't be empty")
# Define messages return type
message_dict = {
"messages" : []
}
# Go through channels
u_channels_list = channels_list_v2(token)["channels"]
for channel in u_channels_list:
msgs = channel_messages_v2(token, channel["channel_id"], 0)
look_for_message(query_str, msgs, message_dict)
while msgs["end"] != -1:
msgs = channel_messages_v2(token, channel["channel_id"], msgs["end"])
look_for_message(query_str, msgs, message_dict)
# Go through dms
u_dms_list = dm_list_v1(token)["dms"]
for dm in u_dms_list:
msgs = dm_messages_v1(token, dm["dm_id"], 0)
look_for_message(query_str, msgs, message_dict)
while msgs["end"] != -1:
msgs = dm_messages_v1(token, dm["dm_id"], msgs["end"])
look_for_message(query_str, msgs, message_dict)
return message_dict
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_channels_list_v2_single_user(user_setup, channel_setup):
'''
list the single channel associated with a single user
'''
assert channels_list_v2(make_token(1)) == {
'channels': [
{
'channel_id': 1,
'name': 'Pchannel',
},
],
}
def test_channels_list_v2_invite(user_setup, channel_setup):
'''
list channels after inviting another user (Non-owner)
'''
channel_invite_v2(make_token(1), 1, 2)
assert channels_list_v2(make_token(1)) == {
'channels': [
{
'channel_id': 1,
'name': 'Pchannel',
},
],
}
def test_single_channel(reg_user, crt_channel, ch_name):
clear_v2()
auth_user_token = reg_user(0)['token']
channel_name = ch_name(0)
channel_id = crt_channel(auth_user_token, 0, True)['channel_id']
channel_list = channels_list_v2(auth_user_token)['channels']
assert len(channel_list) == 1
assert channel_list[0]['channel_id'] == channel_id
assert channel_list[0]['name'] == channel_name
def test_channels_create_valid():
# Test if channel has been successfully created by accessing channels_list_v2
clear_v1()
user_1 = auth_register_v2("*****@*****.**", "password", "Joshua", "King")
channel_1 = channels_create_v2(user_1['token'], "Channel 1",
True)['channel_id']
channel_2 = channels_create_v2(user_1['token'], "Channel 2",
False)['channel_id']
# Check stored values of channel_list_v2
channels_dict = channels_list_v2(user_1['token'])
assert channels_dict['channels'][0]['channel_id'] == channel_1
assert channels_dict['channels'][0]['name'] == 'Channel 1'
assert channels_dict['channels'][1]['channel_id'] == channel_2
assert channels_dict['channels'][1]['name'] == 'Channel 2'
def test_multiple_channels(reg_user, crt_channel, ch_name):
clear_v2()
auth_user_token = reg_user(0)['token']
expected_channels = []
for i in range(5):
channel_id = crt_channel(auth_user_token, i, True)['channel_id']
channel_name = ch_name(i)
expected_channel = {'channel_id': channel_id, 'name': channel_name}
expected_channels.append(expected_channel)
channel_list = channels_list_v2(auth_user_token)['channels']
assert channel_list == expected_channels
def test_multiple_users_multiple_channels(reg_user, crt_channel, ch_name):
clear_v2()
user_1_token = reg_user(0)['token']
user_2_token = reg_user(1)['token']
expected_channels_1 = []
for i in range(5):
channel_id = crt_channel(user_1_token, i, True)['channel_id']
channel_name = ch_name(i)
expected_channel = {'channel_id': channel_id, 'name': channel_name}
expected_channels_1.append(expected_channel)
expected_channels_2 = []
for i in range(5, 10):
channel_id = crt_channel(user_2_token, i, True)['channel_id']
channel_name = ch_name(i)
expected_channel = {'channel_id': channel_id, 'name': channel_name}
expected_channels_2.append(expected_channel)
channel_list_1 = channels_list_v2(user_1_token)['channels']
channel_list_2 = channels_list_v2(user_2_token)['channels']
assert channel_list_1 == expected_channels_1
assert channel_list_2 == expected_channels_2
def is_auth_user_in_channel(token, channel_id):
"""
Checks if the auth_user is in channel with channel_id
Arguments:
token (string) - jwt encoded data structure of auth_user with session_id
channel_id (int) - the channel to check for the u_id
Returns Value:
Returns Boolean
"""
for channel in channels_list_v2(token)["channels"]:
if channel["channel_id"] == channel_id:
return True
return False
def test_non_channel_owner(reg_user, crt_channel, ch_name):
clear_v2()
auth_user_token = reg_user(0)['token']
basic_user_token = reg_user(1)['token']
channel_name = ch_name(0)
channel_id = crt_channel(auth_user_token, 0, True)['channel_id']
channel_join_v2(basic_user_token, channel_id)
channel_list = channels_list_v2(basic_user_token)['channels']
assert len(channel_list) == 1
assert channel_list[0]['channel_id'] == channel_id
assert channel_list[0]['name'] == channel_name
def test_channel_create_v2_basic(reg_user, basic_channel_name): # test if it works
clear_v2()
token_1 = reg_user(0)['token']
channel_name = basic_channel_name
is_public = True
channel_id = channels_create_v2(token_1, channel_name, is_public)['channel_id']
channelList = channels_list_v2(token_1)['channels']
channel_id_found = False
for channel in channelList:
if channel_id == channel['channel_id']:
channel_id_found = True
assert channel_id_found
details = channel_details_v2(token_1, channel_id)
#assert details are what we want
assert details['name'] == channel_name
assert len(details['owner_members']) == 1
assert len(details['all_members']) == 1
assert details['is_public'] == True
def test_multiple_channel():
clear_v1()
user_1 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a')
channel_1 = channels_create_v2(user_1['token'], 'Channel 1', True)
channel_2 = channels_create_v2(user_1['token'], 'Channel 2', False)
channel_3 = channels_create_v2(user_1['token'], 'Channel 3', True)
assert channels_list_v2(user_1['token']) == {
'channels': [{
'channel_id': channel_1['channel_id'],
'name': 'Channel 1'
}, {
'channel_id': channel_2['channel_id'],
'name': 'Channel 2'
}, {
'channel_id': channel_3['channel_id'],
'name': 'Channel 3'
}]
}
clear_v1()
def test_success_global_owner_add(create_input):
# length of *_members for Third Channel before add
assert len(
channel_details_v2(
create_input[0][2]["token"],
create_input[1][2]["channel_id"])["owner_members"]) == 1
assert len(
channel_details_v2(
create_input[0][2]["token"],
create_input[1][2]["channel_id"])["all_members"]) == 1
# create_input[0][0]["token"] is a global owner; can add owners even if they aren't members of the channel
assert channel_addowner_v1(create_input[0][0]["token"],
create_input[1][2]["channel_id"],
create_input[0][1]["auth_user_id"]) == {}
assert channel_addowner_v1(create_input[0][0]["token"],
create_input[1][2]["channel_id"],
create_input[0][3]["auth_user_id"]) == {}
assert channel_addowner_v1(create_input[0][0]["token"],
create_input[1][2]["channel_id"],
create_input[0][0]["auth_user_id"]) == {}
# length of *_members for Third Channel after add; testing for all users
assert len(
channel_details_v2(
create_input[0][0]["token"],
create_input[1][2]["channel_id"])["owner_members"]) == 4
assert len(
channel_details_v2(
create_input[0][0]["token"],
create_input[1][2]["channel_id"])["all_members"]) == 4
assert len(
channel_details_v2(
create_input[0][1]["token"],
create_input[1][2]["channel_id"])["owner_members"]) == 4
assert len(
channel_details_v2(
create_input[0][1]["token"],
create_input[1][2]["channel_id"])["all_members"]) == 4
assert len(
channel_details_v2(
create_input[0][2]["token"],
create_input[1][2]["channel_id"])["owner_members"]) == 4
assert len(
channel_details_v2(
create_input[0][2]["token"],
create_input[1][2]["channel_id"])["all_members"]) == 4
assert len(
channel_details_v2(
create_input[0][3]["token"],
create_input[1][2]["channel_id"])["owner_members"]) == 4
assert len(
channel_details_v2(
create_input[0][3]["token"],
create_input[1][2]["channel_id"])["all_members"]) == 4
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"]) == 2
assert len(channels_list_v2(create_input[0][4]["token"])["channels"]) == 0
def channels_list():
parameters = request.args
token = parameters['token']
output = channels_list_v2(token)
return dumps(output)
def test_success_multiple_join(create_input):
# length of *_members for Second Channel before join
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
assert channel_join_v2(create_input[0][0]["token"],
create_input[1][1]["channel_id"]) == {}
assert channel_join_v2(create_input[0][2]["token"],
create_input[1][1]["channel_id"]) == {}
assert channel_join_v2(create_input[0][3]["token"],
create_input[1][1]["channel_id"]) == {}
# length of *_members for Second Channel after join; testing for all users
assert len(
channel_details_v2(
create_input[0][0]["token"],
create_input[1][1]["channel_id"])["owner_members"]) == 1
assert len(
channel_details_v2(
create_input[0][0]["token"],
create_input[1][1]["channel_id"])["all_members"]) == 4
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"]) == 4
assert len(
channel_details_v2(
create_input[0][2]["token"],
create_input[1][1]["channel_id"])["owner_members"]) == 1
assert len(
channel_details_v2(
create_input[0][2]["token"],
create_input[1][1]["channel_id"])["all_members"]) == 4
assert len(
channel_details_v2(
create_input[0][3]["token"],
create_input[1][1]["channel_id"])["owner_members"]) == 1
assert len(
channel_details_v2(
create_input[0][3]["token"],
create_input[1][1]["channel_id"])["all_members"]) == 4
with pytest.raises(AccessError):
len(
channel_details_v2(
create_input[0][4]["token"],
create_input[1][1]["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"]) == 1
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_members(test_data):
a_data, b_data, c_data, ab_ch_id, c_ch_id = test_data
all_user_profiles = []
all_user_profiles.append(
user_profile_v2(a_data["token"], a_data["auth_user_id"])["user"])
all_user_profiles.append(
user_profile_v2(a_data["token"], b_data["auth_user_id"])["user"])
all_user_profiles.append(
user_profile_v2(a_data["token"], c_data["auth_user_id"])["user"])
ab_details = channel_details_v2(a_data["token"], ab_ch_id)
# check that the name of the channel is correct
is_channel_exist = False
for channel in channels_list_v2(a_data["token"])["channels"]:
if channel["name"] == ab_details["name"]:
is_channel_exist = True
assert is_channel_exist == True
# check is_public
assert ab_details["is_public"] == True
# check owner_members are in all_members
is_member_exist = False
for owner in ab_details["owner_members"]:
if owner in ab_details["all_members"]:
is_member_exist = True
assert is_member_exist == True
# get all members
# see that their information is correct
print(all_user_profiles)
is_member_exist = False
for member in ab_details["all_members"]:
print(member)
if member in all_user_profiles:
is_member_exist = True
assert is_member_exist == True
# check that non-owners recieve the same correct information
ab_details = channel_details_v2(b_data["token"], ab_ch_id)
is_channel_exist = False
for channel in channels_list_v2(b_data["token"])["channels"]:
if channel["name"] == ab_details["name"]:
is_channel_exist = True
assert is_channel_exist == True
assert ab_details["is_public"] == True
is_member_exist = False
for owner in ab_details["owner_members"]:
if owner in ab_details["all_members"]:
is_member_exist = True
assert is_member_exist == True
is_member_exist = False
for member in ab_details["all_members"]:
if member in all_user_profiles:
is_member_exist = True
assert is_member_exist == True
# channel c
c_details = channel_details_v2(c_data["token"], c_ch_id)
is_channel_exist = False
for channel in channels_list_v2(c_data["token"])["channels"]:
if channel["name"] == c_details["name"]:
is_channel_exist = True
assert is_channel_exist == True
assert c_details["is_public"] == False
is_member_exist = False
for owner in c_details["owner_members"]:
if owner in c_details["all_members"]:
is_member_exist = True
assert is_member_exist == True
is_member_exist = False
for member in c_details["all_members"]:
if member in all_user_profiles:
is_member_exist = True
assert is_member_exist == True
def notifications_get_v1(token):
"""
Return the user's most recent 20 notifications
Parameters:
token (string) - string that stores user data of caller
Exceptions:
AccessError - Occurs when token is invalid
Returns:
notifications - List of dictionaries, where each dictionary contains types { channel_id, dm_id, notification_message }
"""
with open("data.json", "r") as json_file:
data = load(json_file)
data_structure = token_check(token)
user_handle = user_profile_v2(token,
data_structure["u_id"])["user"]["handle_str"]
raw_notifs = []
# CHANNEL MESSAGES
channel_list = channels_list_v2(token)["channels"]
channel_id_list = []
for channel in channel_list:
channel_id_list.append(channel["channel_id"])
# go through every single channel for their messages
for channel in channel_list:
for message in channel_messages_v2(token, channel["channel_id"],
0)["messages"]:
# for each of these messages look for the tag
if f"@{user_handle}" in message["message"]:
# add them to a list of tagged messages
# use string range [:] to get the latest 20 of them
raw_notifs.append({
"notif": [
CHANNEL, TAG, message["u_id"], channel["channel_id"],
channel["name"], message["message"][:20]
],
"time_stamp":
message["time_created"]
})
# for each of these messages look at the reacts
if message["u_id"] == data_structure["u_id"] and len(
message["react_history"]) > 0:
for react in message["react_history"]:
raw_notifs.append({
"notif": [
CHANNEL, REACT, react["u_id"],
channel["channel_id"], channel["name"]
],
"time_stamp":
react["time_stamp"]
})
# CHANNEL INVITES
for channel in data["channels"]:
if channel["channel_id"] in channel_id_list:
for invite in channel["invites"]:
if invite["u_id"] == data_structure["u_id"]:
raw_notifs.append({
"notif": [
CHANNEL, INVITE, invite["auth_user_id"],
channel["channel_id"], channel["name"]
],
"time_stamp":
invite["time_invited"]
})
# DM MESSAGES
dm_list = dm_list_v1(token)["dms"]
dm_id_list = []
for dm in dm_list:
dm_id_list.append(dm["dm_id"])
for dm in dm_list:
for message in dm_messages_v1(token, dm["dm_id"], 0)["messages"]:
if f"@{user_handle}" in message["message"]:
raw_notifs.append({
"notif": [
DM, TAG, message["u_id"], dm["dm_id"], dm["name"],
message["message"][:20]
],
"time_stamp":
message["time_created"]
})
if message["u_id"] == data_structure["u_id"] and len(
message["react_history"]) > 0:
for react in message["react_history"]:
raw_notifs.append({
"notif":
[DM, REACT, react["u_id"], dm["dm_id"], dm["name"]],
"time_stamp":
react["time_stamp"]
})
# DM INVITES
for dm in data["dms"]:
if dm["dm_id"] in dm_id_list:
for invite in dm["invites"]:
if invite["u_id"] == data_structure["u_id"]:
raw_notifs.append({
"notif": [
DM, INVITE, invite["auth_user_id"], dm["dm_id"],
dm["name"]
],
"time_stamp":
invite["time_invited"]
})
# sort them by time
raw_notifs.sort(reverse=True, key=sort_time_stamp)
raw_notifs = raw_notifs[:20]
# format the notifications
notifs = []
"""
tagged: "{User’s handle} tagged you in {channel/DM name}: {first 20 characters of the message}"
added to a channel/DM: "{User’s handle} added you to {channel/DM name}
"""
for notif in raw_notifs:
# find user handle
notif = notif["notif"]
for user in data["users"]:
if user["u_id"] == notif[AUTH_U_ID]:
auth_user_handle = user["handle_str"]
if notif[CHAT_TYPE] == CHANNEL:
channel_id = notif[CHAT_ID]
dm_id = -1
else:
dm_id = notif[CHAT_ID]
channel_id = -1
if notif[NOTIF_TYPE] == TAG:
notifs.append({
"channel_id":
channel_id,
"dm_id":
dm_id,
"notification_message":
f"{auth_user_handle} tagged you in {notif[NAME]}: {notif[MESSAGE]}"
})
elif notif[NOTIF_TYPE] == INVITE:
notifs.append({
"channel_id":
channel_id,
"dm_id":
dm_id,
"notification_message":
f"{auth_user_handle} added you to {notif[NAME]}"
})
else: # notif[NOTIF_TYPE] == REACT:
notifs.append({
"channel_id":
channel_id,
"dm_id":
dm_id,
"notification_message":
f"{auth_user_handle} reacted to your message in {notif[NAME]}"
})
return {"notifications": notifs}
def test_invalid_token(reg_user):
clear_v2()
reg_user(0)['token']
with pytest.raises(AccessError):
channels_list_v2("Invalid token")['channels']
def test_empty_list():
clear_v1()
user_1 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a')
assert channels_list_v2(user_1['token']) == {'channels': []}
clear_v1()
def channels_list():
token = request.args.get('token')
output = channels_list_v2(token)
return dumps(output)
