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', }, ], }