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)