def test_addowner_slackr(): """ Tests if channel_addowner works if Slackr owner who is not a channel owner tries to use it """ user1 = auth.auth_register("*****@*****.**", "password", "Severus", "Snape") user2 = auth.auth_register("*****@*****.**", "password", "Albus", "Dumbledore") user3 = auth.auth_register("*****@*****.**", "Potions", "Harry", "Potter") c_id_dict = channels.channels_create(user2["token"], "test_channel", True) channel.channel_join(user1["token"], c_id_dict["channel_id"]) channel.channel_join(user3["token"], c_id_dict["channel_id"]) details_before = channel.channel_details(user2["token"], c_id_dict["channel_id"]) assert details_before["owner_members"][0]["u_id"] == user2["u_id"] assert details_before["owner_members"][1]["u_id"] == user1["u_id"] assert len(details_before["owner_members"]) == 2 assert len(details_before["all_members"]) == 3 assert details_before["all_members"][2]["u_id"] == user3["u_id"] channel.channel_addowner(user1["token"], c_id_dict["channel_id"], user3["u_id"]) details_after = channel.channel_details(user2["token"], c_id_dict["channel_id"]) assert len(details_after["owner_members"]) == 3 assert details_after["owner_members"][0]["u_id"] == user2["u_id"] assert details_after["owner_members"][1]["u_id"] == user1["u_id"] assert details_after["owner_members"][2]["u_id"] == user3["u_id"]
def test_join_admin(): """ Tests if channel_join allows an admin to join a private channel """ # establish a test register # since test_dict is first member he is owner of slackr/admin (per assumptions) test_dict = auth.auth_register("*****@*****.**", "password", "Bob", "Ross") # create a second user test_dict_2 = auth.auth_register("*****@*****.**", "password2", "James", "May") # second user creates a private channel (which bob ross is not a part of) c_id_dict = channels.channels_create(test_dict_2["token"], "test admin", False) # store details before using channel_join details_before = channel.channel_details(test_dict_2["token"], c_id_dict["channel_id"]) # check that only test_dict_2 is owner in channel assert len(details_before["owner_members"]) == 1 assert details_before["owner_members"][0]["u_id"] == test_dict_2["u_id"] # we then test that test_dict(admin) can join the private channel channel.channel_join(test_dict["token"], c_id_dict["channel_id"]) details_after = channel.channel_details(test_dict_2["token"], c_id_dict["channel_id"]) # we check that there are now two owners in the channel assert len(details_after["owner_members"]) == 2 assert details_after["owner_members"][0]["u_id"] == test_dict_2["u_id"] assert details_after["owner_members"][1]["u_id"] == test_dict["u_id"]
def test_addowner_channel(): """ Tests if channel_addowner works if user is a channel owner but not a Slackr owner """ user1 = auth.auth_register("*****@*****.**", "password", "Earthworm", "Jim") user2 = auth.auth_register("*****@*****.**", "password", "Gabe", "Newell") user3 = auth.auth_register("*****@*****.**", "Potions", "Harry", "Potter") # user2 creates a channel, they should be the only owner c_id_dict = channels.channels_create(user2["token"], "test_channel", True) channel.channel_join(user3["token"], c_id_dict["channel_id"]) details_before = channel.channel_details(user2["token"], c_id_dict["channel_id"]) assert details_before["owner_members"][0]["u_id"] == user2["u_id"] assert len(details_before["owner_members"]) == 1 # user2 makes user3 an owner, channel_details should now show two owners channel.channel_addowner(user2["token"], c_id_dict["channel_id"], user3["u_id"]) details_after = channel.channel_details(user2["token"], c_id_dict["channel_id"]) assert len(details_after["owner_members"]) == 2 assert details_after["owner_members"][0]["u_id"] == user2["u_id"] assert details_after["owner_members"][1]["u_id"] == user3["u_id"] # user1 (admin) joins the channel, he should be owner channel.channel_join(user1["token"], c_id_dict["channel_id"]) details_admin = channel.channel_details(user1["token"], c_id_dict["channel_id"]) assert len(details_admin["owner_members"]) == 3 assert details_admin["owner_members"][2]["u_id"] == user1["u_id"]
def test_leave_valid(): """ Tests if channel_leave works with a valid token and channel ID """ # establish a test register test_dict = auth.auth_register("*****@*****.**", "password", "Bob", "Ross") # valid channel ID (assigned by channels_create) c_id_dict = channels.channels_create(test_dict["token"], "test rum ham", True) # create a second user and add them to the channel test_dict_2 = auth.auth_register("*****@*****.**", "password2", "James", "May") channel.channel_join(test_dict_2["token"], c_id_dict["channel_id"]) # store our details before the leave details_before = channel.channel_details(test_dict["token"], c_id_dict["channel_id"]) # ensure there are two members: test_dict & test_dict_2 assert len(details_before["all_members"]) == 2 assert details_before["all_members"][0]["u_id"] == test_dict["u_id"] assert details_before["all_members"][1]["u_id"] == test_dict_2["u_id"] # test channel_leave to have James May(test_dict_2) leave channel.channel_leave(test_dict_2["token"], c_id_dict["channel_id"]) # check that "test rum ham" only has 1 user in it: Bob Ross details_after = channel.channel_details(test_dict["token"], c_id_dict["channel_id"]) assert len(details_after["all_members"]) == 1 assert details_after["all_members"][0]["u_id"] == test_dict["u_id"]
def test_channel_add_owner(): results = auth_register("*****@*****.**", '123!Asdf', 'John', 'Smith') results = auth_login('*****@*****.**', '123!Asdf') token1 = results['token'] results2 = auth_register('*****@*****.**', 'zxc123asd', 'Bob', 'Builder') results2 = auth_login('*****@*****.**', 'zxc123asd') u_id2 = results2['u_id'] token2 = results2['token'] channel_info3 = channels_create(token1, 'Slakrs', True) channel_addowner(token1, channel_info3, u_id2) owners = channel_details(token2, channel_info3)['owner_members'] print(channel_details(token2, channel_info3)) print(owners[0]['u_id']) is_owner = 0 j = 0 for i in owners: if u_id2 == owners[j]['u_id']: is_owner = 1 j = +1 assert is_owner == 1
def test_channel_addowner_user_slackr_owner(auth_fixture): ''' Test case when authorised user is an owner of the slackr ''' (server_data, auth_fixture) = auth_fixture # get user details tokenslackr = auth_fixture[0]['token'] token1 = auth_fixture[1]['token'] token2 = auth_fixture[2]['token'] u_id2 = auth_fixture[2]['u_id'] # create channels with 1 user (user 1 is owner) channel_id1 = channels_create(server_data, token1, 'New_Channel', True)['channel_id'] channel_id2 = channels_create(server_data, token1, 'Another_Channel', True)['channel_id'] # add user2 as member to channel1 channel_invite(server_data, token1, channel_id1, u_id2) # slackrowner adds user2 as owner for channel1 (which user2 is a member of) and channel2 (which user2 is not a member of) channel_addowner(server_data, tokenslackr, channel_id1, u_id2) channel_addowner(server_data, tokenslackr, channel_id2, u_id2) # get details of channels user2_channel_det1 = channel_details(server_data, token2, channel_id1)['owner_members'] user2_channel_det2 = channel_details(server_data, token2, channel_id2)['owner_members'] # check that user2 is an owner for both channels assert any(True for i in user2_channel_det1 if i['u_id'] == u_id2) assert any(True for i in user2_channel_det2 if i['u_id'] == u_id2)
def test_clear_users(): ''' Test that clear() removes the users[] ''' # Test basic functionality initially clear() f_owner = auth_register('*****@*****.**', 'password', 'Bob', 'Bob') f_channel = channels_create(f_owner['token'], 'Channel 1', True) details = channel_details(f_owner['token'], f_channel['channel_id']) assert len(details['all_members']) == 1 assert len(details['owner_members']) == 1 random_user = auth_register('*****@*****.**', 'password', 'Random', 'User') channel_invite(f_owner['token'], f_channel['channel_id'], random_user['u_id']) details = channel_details(f_owner['token'], f_channel['channel_id']) assert len(details['all_members']) == 2 assert len(details['owner_members']) == 1 # Cannot register someone who's already a Flockr member clear() with pytest.raises(AccessError): details = channel_details(f_owner['token'], f_channel['channel_id']) auth_register('*****@*****.**', 'password', 'Bob', 'Bob') with pytest.raises(InputError): auth_register('*****@*****.**', 'password', 'Bob', 'Bob') clear() auth_register('*****@*****.**', 'password', 'Bob', 'Bob')
def test_channel_details_unauthorised_user(channel_init): ''' test_channel_details_unauthorised_user ''' with pytest.raises(AccessError): #Test with valid channel_id channel_details(channel_init[3]['token'], channel_init[2])
def test_channel_invite_simple(): clear() usera, userb = register_n_users(2) channel_id = channels_create(userb["token"], "userb_channel", False)["channel_id"] usera_info = { "u_id": usera["u_id"], "name_first": auth_get_user_data_from_id(usera["u_id"])["first_name"], "name_last": auth_get_user_data_from_id(usera["u_id"])["last_name"], "profile_img_url": auth_get_user_data_from_id(usera["u_id"])["profile_img_url"], } channel_members_info = channel_details(userb["token"], channel_id)["all_members"] assert usera_info not in channel_members_info channel_invite(userb["token"], channel_id, usera["u_id"]) updated_channel_members_info = channel_details(userb["token"], channel_id)["all_members"] assert usera_info in updated_channel_members_info
def test_join_standard(): info = starter() u1, u2, u3, c1 = info[1], info[2], info[3], info[4] # store user information u3_info = { 'u_id': u3['u_id'], 'name_first': 'Charlie', 'name_last': 'Barry' } u1_info = { 'u_id': u1['u_id'], 'name_first': 'Elizabeth', 'name_last': 'Alexander' } u2_info = {'u_id': u2['u_id'], 'name_first': 'Jane', 'name_last': 'Anton'} # user 1 joins public channel channel.channel_join(u1['token'], c1['channel_id']) details = channel.channel_details(u1['token'], c1['channel_id']) # user 1 should appear in channel members list assert details['all_members'] == [u3_info, u1_info] # user 1 should NOT be in channel owners list assert details['owner_members'] == [u3_info] # user 2 joins public channel channel.channel_join(u2['token'], c1['channel_id']) details = channel.channel_details(u2['token'], c1['channel_id']) # both users 1 and 2 should appear in list of channel members assert details['all_members'] == [u3_info, u1_info, u2_info] # users 1 and 2 should NOT appear in channel owners list assert details['owner_members'] == [u3_info]
def test_channel_join_multiple_channels(): clear() usera, userb, userc = register_n_users(3) channel_id_a = channels_create(usera["token"], "channela", is_public=True)["channel_id"] channel_id_b = channels_create(userb["token"], "channelb", is_public=True)["channel_id"] channel_id_c = channels_create(userc["token"], "channelc", is_public=True)["channel_id"] channel_join(usera["token"], channel_id_b) channel_join(usera["token"], channel_id_c) channel_join(userb["token"], channel_id_c) # usera should be able to get all the details since the channels are public detailsa = channel_details(usera["token"], channel_id_a) detailsb = channel_details(usera["token"], channel_id_b) detailsc = channel_details(usera["token"], channel_id_c) # there should still be only one owner assert_contains_users_id(detailsa["owner_members"], [usera["u_id"]]) assert_contains_users_id(detailsb["owner_members"], [userb["u_id"]]) assert_contains_users_id(detailsc["owner_members"], [userc["u_id"]]) assert_contains_users_id(detailsa["all_members"], [usera["u_id"]]) assert_contains_users_id(detailsb["all_members"], [usera["u_id"], userb["u_id"]]) assert_contains_users_id(detailsc["all_members"], [usera["u_id"], userb["u_id"], userc["u_id"]])
def test_admin_valid_permission_change(auth_fixture): """ Pytest: testing valid requests """ (server_data, auth_fixture) = auth_fixture token = auth_fixture[0]["token"] token1 = auth_fixture[1]["token"] token2 = auth_fixture[2]["token"] token3 = auth_fixture[3]["token"] token4 = auth_fixture[4]["token"] u_id1 = auth_fixture[1]["u_id"] u_id2 = auth_fixture[2]["u_id"] u_id3 = auth_fixture[3]["u_id"] u_id4 = auth_fixture[4]["u_id"] # Change all of them to owner admin_userpermission_change(server_data, token, u_id1, const.PERMISSION_GLOBAL_OWNER) admin_userpermission_change(server_data, token, u_id2, const.PERMISSION_GLOBAL_OWNER) admin_userpermission_change(server_data, token, u_id3, const.PERMISSION_GLOBAL_OWNER) admin_userpermission_change(server_data, token, u_id4, const.PERMISSION_GLOBAL_OWNER) # user 0 now create a channel channel_info = channels_create(server_data, token, "TEST1", True) # All other users join the channel, they should automatically become owners channel_join(server_data, token1, channel_info["channel_id"]) channel_join(server_data, token2, channel_info["channel_id"]) channel_join(server_data, token3, channel_info["channel_id"]) channel_join(server_data, token4, channel_info["channel_id"]) # Get channel details and check rt_info = channel_details(server_data, token, channel_info["channel_id"]) assert len(rt_info["owner_members"]) == 5 assert len(rt_info["all_members"]) == 5 # Test other users to change permission, it should not fail admin_userpermission_change(server_data, token2, u_id1, const.PERMISSION_GLOBAL_MEMBER) admin_userpermission_change(server_data, token2, u_id3, const.PERMISSION_GLOBAL_MEMBER) admin_userpermission_change(server_data, token2, u_id4, const.PERMISSION_GLOBAL_MEMBER) # Create a second channel to test channel_info = channels_create(server_data, token, "TEST1", True) channel_join(server_data, token1, channel_info["channel_id"]) channel_join(server_data, token2, channel_info["channel_id"]) channel_join(server_data, token3, channel_info["channel_id"]) channel_join(server_data, token4, channel_info["channel_id"]) # Get channel details and check rt_info = channel_details(server_data, token, channel_info["channel_id"]) assert len(rt_info["owner_members"]) == 2 assert len(rt_info["all_members"]) == 5
def test_removeowner_standard(): info = starter() u1, u2, u3, c1 = info[1], info[2], info[3], info[4] # get user information u2_info = {'u_id': u2['u_id'], 'name_first': 'Jane', 'name_last': 'Anton'} u3_info = { 'u_id': u3['u_id'], 'name_first': 'Charlie', 'name_last': 'Barry' } # user 3 adds user 1 as an owner channel.channel_addowner(u3['token'], c1['channel_id'], u1['u_id']) # user 3 adds user 2 as an owner channel.channel_addowner(u3['token'], c1['channel_id'], u2['u_id']) # user 2 removes user 1 as owner channel.channel_removeowner(u2['token'], c1['channel_id'], u1['u_id']) # user 1 should not be in owners list details = channel.channel_details(u2['token'], c1['channel_id']) assert details['owner_members'] == [u3_info, u2_info] # user 2 removes herself as channel owner channel.channel_removeowner(u2['token'], c1['channel_id'], u2['u_id']) # channel should have one owner now details = channel.channel_details(u2['token'], c1['channel_id']) assert details['owner_members'] == [u3_info]
def test_channel_leave_correct_details(reset, create_private_channel, create_user1): ''' Testing channel is actually updated if user leaves by using channel_details ''' # creating user and channel new_ch, owner_info = create_private_channel user_info = create_user1 # inviting user channel_invite(owner_info["token"], new_ch["channel_id"], user_info["u_id"]) # getting details all_membs = channel_details(owner_info['token'], new_ch['channel_id'])['all_members'] u_ids = [member['u_id'] for member in all_membs] # asserting user is in the channel assert user_info['u_id'] in u_ids assert len(all_membs) == 3 channel_leave(user_info["token"], new_ch["channel_id"]) # getting details all_membs = channel_details(owner_info['token'], new_ch['channel_id'])['all_members'] u_ids = [member['u_id'] for member in all_membs] assert user_info['u_id'] not in u_ids assert len(all_membs) == 2
def test_database_clear(): # use some test helpers to populate with some more realistic data usera = auth_register("*****@*****.**", "veryverysafe", "safety", "first") userb = auth_register("*****@*****.**", "nostress", "safety", "second") channels_create(usera["token"], "first_channel", is_public=True) channels_create(userb["token"], "second_channel", is_public=True) channels_create(userb["token"], "p_channel", is_public=False) clear() # the spec doesn't specifiy which of the InputError and AccessError should # be raised first. This is an implementation detail, and since we are doing # black box testing, we shouldn't rely on that. with pytest.raises(Exception): channel_details(usera["token"], "first_channel") with pytest.raises(Exception): channels_listall(usera["token"]) # assert len(channels_listall(usera['token'])) == 0 with pytest.raises(InputError): auth_login("*****@*****.**", "veryverysafe") with pytest.raises(InputError): auth_login("*****@*****.**", "nostress")
def test_channel_details_invalid_channel(channel_init): ''' test_channel_details_invalid_channel ''' with pytest.raises(InputError): #Test with valid user channel_details(channel_init[0]['token'], "")
def test_channel_removeowner(auth_fixture): ''' Test case for a simple channel removeowner - owner removing another owner in the same channel ''' (server_data, auth_fixture) = auth_fixture # get user details token1 = auth_fixture[1]['token'] token2 = auth_fixture[2]['token'] uid2 = auth_fixture[2]['u_id'] # create channels with user1 then add user2 as owner pub_channel_id = channels_create(server_data, token1, 'New_Channel', True)['channel_id'] priv_channel_id = channels_create(server_data, token1, 'Priv_Channel', False)['channel_id'] channel_addowner(server_data, token1, pub_channel_id, uid2) channel_addowner(server_data, token1, priv_channel_id, uid2) # user1 removes user2 from owner permissions channel_removeowner(server_data, token1, pub_channel_id, uid2) channel_removeowner(server_data, token1, priv_channel_id, uid2) # check channel details to make sure user 2 is a non owner member user2_channel_det1 = channel_details(server_data, token2, pub_channel_id)['owner_members'] user2_channel_det2 = channel_details(server_data, token2, priv_channel_id)['owner_members'] # owner member list should not have any ids equal to the id of user2 assert not any(True for i in user2_channel_det1 if i['u_id'] == uid2) assert not any(True for i in user2_channel_det2 if i['u_id'] == uid2)
def test_user_profile_setname_updated_on_channel(): ''' Test that user's details get updated on the channel ''' other.clear() owner = auth.auth_register("*****@*****.**", "testpass", "First", "User") test_user = auth.auth_register("*****@*****.**", "password", "Notedited", "Alsonotedited") channel_1 = channels.channels_create(owner['token'], "Test Channel", True) channels.channels_create(owner['token'], "Test Channel 2", True) channel_3 = channels.channels_create(test_user['token'], "Test Channel 2", True) channel.channel_join(test_user['token'], channel_1['channel_id']) channel.channel_join(owner['token'], channel_3['channel_id']) details = channel.channel_details(test_user['token'], channel_1['channel_id']) owner_dict = { 'u_id': owner['u_id'], 'name_first': "First", 'name_last': "User", 'profile_img_url': "" } test_user_dict = { 'u_id': test_user['u_id'], 'name_first': "Notedited", 'name_last': "Alsonotedited", 'profile_img_url': "" } assert details == { 'name': 'Test Channel', 'owner_members': [owner_dict], 'all_members': [owner_dict, test_user_dict] } user.user_profile_setname(test_user['token'], "Newname", "Nowedited") user.user_profile_setname(owner['token'], "Firstedited", "Nowedited") details = channel.channel_details(test_user['token'], channel_1['channel_id']) owner_dict = { 'u_id': owner['u_id'], 'name_first': "Firstedited", 'name_last': "Nowedited", 'profile_img_url': "" } test_user_dict = { 'u_id': test_user['u_id'], 'name_first': "Newname", 'name_last': "Nowedited", 'profile_img_url': "" } assert details == { 'name': 'Test Channel', 'owner_members': [owner_dict], 'all_members': [owner_dict, test_user_dict] }
def test_channel_details_invalid_token(reset, create_public_channel, create_user1): ''' Access Error occurs when an unauthorized user invokes the function ''' channel_id = create_public_channel[0] with pytest.raises(AccessError): channel_details("I am an invalid token", channel_id['channel_id'])
def test_not_member_of_channel(): '''test for access error''' reset_data() owner = auth_register("*****@*****.**", "hellocse", "jiaqi", "zhu") user = auth_register("*****@*****.**", "iamrobert", "Robert", "Cad") test_channel = channels.channels_create(owner['token'], "New Channel", True) with pytest.raises(AccessError): channel.channel_details(user['token'], test_channel['channel_id'])
def test_channel_details_wrong_channel_id(): user_1 = auth_register("*****@*****.**", "12345678", "Devansh", "Kala") user_1_user_id = user_1["u_id"] user_1_token = user_1["token"] new_channel = channels_create(user_1_token, "NEWCHANNEL", True) new_channel_channel_id = new_channel["channel_id"] with pytest.raises(InputError) as e: channel_details(user_1_token, new_channel_channel_id * 6789)
def test_channel_details_no_id(reset, create_private_channel): ''' Input error when channel_id does not exist ''' channel_id, owner_info = create_private_channel non_channel_id = channel_id['channel_id'] + 1 with pytest.raises(InputError): channel_details(owner_info['token'], non_channel_id)
def test_create_private(): clear() usera, userb = register_n_users(2) channel = channels_create(usera["token"], "channel", is_public=False) details = channel_details(usera["token"], channel["channel_id"]) assert details["name"] == "channel" with pytest.raises(AccessError): channel_details(userb["token"], channel["channel_id"])
def test_channel_details_invalid_channel(): ''' Testing for when a Channel ID is not a valid channel ''' clear() token = auth_register('*****@*****.**', '123abc!@#', 'Hayden', 'Everest', None)['token'] channel_id = channels_create(token, 'TestChannel', True)['channel_id'] with pytest.raises(InputError): channel_details(token, channel_id + 100)
def test_details_invalid_channel(): ''' Testing when channel is invalid. ''' clear() user = auth_register("*****@*****.**", 'erenyaegar', 'ando', 'pech') user_token = user.get("token") channels_create(user_token, "a", True) with pytest.raises(InputError): channel_details(user_token, "invalid channel")
def test_channel_details_not_member(): """Testing an invalid member passed into channel_details""" clear() valid_user = auth_register("*****@*****.**", "validPassword", "Validate", "Me") invalid_user = auth_register("*****@*****.**", "invalidPassword", "Invalidate", "Mee") channels_create(valid_user["token"], "testing_invalid_user", False) with pytest.raises(AccessError): channel_details(invalid_user["token"], 1)
def test_channel_details_wrong_id(): other.clear() user_1 = auth.auth_register("*****@*****.**", "abcd1234", "John", "Smith") channels.channels_create(user_1['token'], "Test Channel", True) with pytest.raises(InputError): channel.channel_details(user_1['token'], 2) other.clear()
def test_channel_details_non_member(reset, create_user1, create_public_channel): ''' Access Error occurs when a user that does not belong to a channel attempts to retrieve its details ''' channel_id = create_public_channel[0] user_info = create_user1 with pytest.raises(AccessError): channel_details(user_info['token'], channel_id['channel_id'])
def test_remove_owner_with_the_only_member(): clear() # register a owner and remove its owner user_A = register_n_users(1) public_channel = channels_create(user_A["token"], "public_channel", True) channel_removeowner(user_A["token"], public_channel["channel_id"], user_A["u_id"]) # if a owner is the only member of a channel, we expect him leaving the channel after # remove owner, so he won't have authority to access the channel with pytest.raises(AccessError): channel_details(user_A["token"], public_channel["channel_id"])
def test_channel_details_no_permission(channels_fixture): """ Function to test channel_details with no permissions """ (server_data, channels_fixture) = channels_fixture token = channels_fixture[1]["token"] channel_id = channels_fixture[3]["channels"][0]["channel_id"] with pytest.raises(AccessError): channel_details(server_data, token, channel_id)