def test_join_nvt(): """ tests if channel_join returns an access error if invalid token used """ # 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 an invalid token invalid_token = 100 # test for AccessError with pytest.raises(error.AccessError): channel.channel_join(invalid_token, c_id_dict["channel_id"])
def test_addowner_already_owner(): ''' Testing when an owner is being added as an owner to the channel. ''' clear() user = auth_register("*****@*****.**", "password", "Firstname", "Lastname") user_token = user.get("token") user_id = user.get("u_id") channels_return = channels_create(user_token, "username", True) channel_id = channels_return.get("channel_id") # channel_join(user_token, channel_id) with pytest.raises(InputError): channel_addowner(user_token, channel_id, user_id)
def test_invalid_user(): ''' Testing when user is invalid. ''' clear() user2 = auth_register("*****@*****.**", 'password', 'abcd2', 'efgh2') user_token2 = user2.get("token") channel = channels_create(user_token2, "Channel1", True) channel_id = channel.get("channel_id") invalid_token = 12312312 with pytest.raises(InputError): channel_details(invalid_token, channel_id)
def test_invalid_user_remove(): ''' Testing when channel_remove is invalid. ''' clear() user2 = auth_register("*****@*****.**", 'password', 'abcd2', 'efgh2') user_token2 = user2.get("token") channel = channels_create(user_token2, "Channel1", True) channel.get("channel_id") user_id = 123123 with pytest.raises(InputError): channel_removeowner(user_token2, "channel_id", user_id)
def initial_users(): clear() auth_register('*****@*****.**', 'password', 'first_name', 'last_name') auth_login('*****@*****.**', 'password') auth_register('*****@*****.**', 'password', 'user2_name', 'user2_name') auth_login('*****@*****.**', 'password') auth_register('*****@*****.**', 'password', 'user3_first_name', 'user3_last_name') auth_login('*****@*****.**', 'password')
def test_channel_join(): ''' Testing the channel_join function ''' clear() owner = auth_register('*****@*****.**', 'password', 'Peter', 'Michaels') channel1 = channels_create(owner['token'], 'Channel 1', True) user = auth_register('*****@*****.**', 'password', 'Kim', 'Williams') details = channel_details(owner['token'], channel1['channel_id']) assert len(details['all_members']) == 1 # Checking if a user can join a channel # (verified if number of members becomes 2 and if they can leave the channel) channel_join(user['token'], channel1['channel_id']) details = channel_details(user['token'], channel1['channel_id']) assert len(details['all_members']) == 2 channel_leave(user['token'], channel1['channel_id']) # Authorised user does not have a valid token with pytest.raises(AccessError): channel_join('', channel1['channel_id']) # Channel ID is not a valid channel with pytest.raises(InputError): channel_join(user['token'], channel1['channel_id'] + 100) # Channel ID is a private channel (authorised user is not a global owner) channel2 = channels_create(owner['token'], 'Channel 2', False) with pytest.raises(AccessError): channel_join(user['token'], channel2['channel_id']) # User joining multiple times - doesn't raise error channel_join(user['token'], channel1['channel_id']) channel_join(user['token'], channel1['channel_id'])
def test_channel_invite(): ''' Testing the channel_invite function ''' clear() owner = auth_register('*****@*****.**', 'password', 'John', 'Smith') user = auth_register('*****@*****.**', 'password', 'Steve', 'Jackson') # User 1 creates a new channel, and invites User 2 channel1 = channels_create(owner['token'], 'Test Channel 1', True) channel_invite(owner['token'], channel1['channel_id'], user['u_id']) # Already invited channel_invite(owner['token'], channel1['channel_id'], user['u_id']) # Checking if User 2 is a member of the channel (whether they can access channel details) channel_details(user['token'], channel1['channel_id']) channel2 = channels_create(owner['token'], 'Test Channel 2', True) # Authorised user does not have a valid token with pytest.raises(AccessError): channel_invite('', channel2['channel_id'], user['u_id']) # Channel ID does not refer to a valid channel with pytest.raises(InputError): channel_invite(owner['token'], channel2['channel_id'] + 100, user['u_id']) # User ID does not refer to a valid user with pytest.raises(InputError): channel_invite(owner['token'], channel2['channel_id'], user['u_id'] + 100) # Authorised user is not a member of the channel with pytest.raises(AccessError): user3 = auth_register('*****@*****.**', 'password', 'Jim', 'Johnson') channel_invite(user3['token'], channel2['channel_id'], user['u_id'])
def test_message_unpin_valid0(): '''Owner of the channel pin the message sent by a member, then the message is unpinned by the owner of flockr''' clear() # Register user 0 user0_info = auth_register("*****@*****.**", "ihfeh3hgi00d", "Yilang", "W") # Register user 1 user1_info = auth_register("*****@*****.**", "VukkFs", "Bill", "Gates") # Register user 2 user2_info = auth_register("*****@*****.**", "RFVtgb45678", "M", "Johnson") # User 0 create a channel channel0_info = channels_create(user0_info['token'], "channel0", True) # User 1 join the channel channel_join(user1_info['token'], channel0_info['channel_id']) # User 1 create another channel channel1_info = channels_create(user1_info['token'], "channel1", True) # User 2 join channel1 channel_join(user2_info['token'], channel1_info['channel_id']) # User 0 join channel1 channel_join(user0_info['token'], channel1_info['channel_id']) # User 2 send a message message0_info = message_send(user2_info['token'], channel1_info['channel_id'], "Hello") # USer 1 send a message message_send(user1_info['token'], channel1_info['channel_id'], "Hi") # User 1 pin the message sent by user 2 message_pin(user1_info['token'], message0_info['message_id']) # User 0 unpin the message just pinned by user 1 message_unpin(user0_info['token'], message0_info['message_id']) # User 0 get all channel messages all_message_info = channel_messages(user0_info['token'], channel1_info['channel_id'], 0) assert all_message_info['messages'][0]['is_pinned'] == False
def test_auth_passwordreset_request_unregistered_email_muplitple_users(): clear() auth_register('*****@*****.**', 'password', 'madeline', 'younes') auth_register('*****@*****.**', '238hadJHJ', 'Mira', 'Bankstone') auth_register('*****@*****.**', '82hBKH', 'Thomas', 'Yossef') with pytest.raises(InputError): auth_passwordreset_request('*****@*****.**')
def test_channel_leave_public_channel(): other.clear() user1 = auth.auth_register("*****@*****.**", "password", "John", "Smith") user2 = auth.auth_register("*****@*****.**", "password", "Will", "Smith") channel_1 = channels.channels_create(user1['token'], "channel_1", True) channel.channel_join(user2['token'], channel_1['channel_id']) user1_dict = { 'u_id': user1['u_id'], 'name_first': 'John', 'name_last': 'Smith', 'profile_img_url': "" } user2_dict = { 'u_id': user2['u_id'], 'name_first': 'Will', 'name_last': 'Smith', 'profile_img_url': "" } assert channel.channel_details(user2['token'], channel_1['channel_id']) == { 'name': 'channel_1', 'owner_members': [user1_dict], 'all_members': [user1_dict, user2_dict] } channel.channel_leave(user2['token'], channel_1['channel_id']) assert channel.channel_details(user1['token'], channel_1['channel_id']) == { 'name': 'channel_1', 'owner_members': [user1_dict], 'all_members': [user1_dict] }
def test_channels_leave(): ''' Tests for channel_leave ''' clear() #Creating users to create channels user1 = auth_register("*****@*****.**", "user1pass", "user1", "last1", None) user2 = auth_register("*****@*****.**", "user2pass", "user2", "last2", None) token1 = user1['token'] token2 = user2['token'] u_id1 = user1['u_id'] u_id2 = user2['u_id'] #creating channels ch_id1 = channels_create(token1, "aGreatChannel", True)['channel_id'] ch_id2 = channels_create(token2, "yetAnotherChannel", False)['channel_id'] with pytest.raises(InputError): #test for invalid channel channel_leave(token1, 50) with pytest.raises(AccessError): #test for user not already member of the channel channel_leave(token2, ch_id1) #test leaving a public channel channel_leave(token1, ch_id1) assert not user_in_channel_persist(u_id1, ch_id1) assert not user_a_member_persist(u_id1, ch_id1) # test leaving a private channel channel_leave(token2, ch_id2) assert not user_in_channel_persist(u_id2, ch_id2) assert not user_a_member_persist(u_id2, ch_id2) clear()
def test_check_channel_is_public(): """ check_channel_is_public returns nothing if the channel is public check_channel_is_public raises an AccessError if the channel is private """ user1 = auth.auth_register("*****@*****.**", "gotosleep", "assoonasi", "finishthis") channel1 = channels.channels_create(user1["token"], "thisispublicwoo", True) channel2 = channels.channels_create(user1["token"], "someoneelsecandodata", False) assert validation.check_channel_is_public(channel1["channel_id"]) == None with pytest.raises(AccessError): assert validation.check_channel_is_public(channel2["channel_id"]) other.clear()
def test_channel_listall_user_not_in_a_channel(): ''' Testing when user not in a channel. ''' clear() valid_viewer = auth_register("*****@*****.**", "passwordOne", "Firstone", "Lastone") valid_viewer_token = valid_viewer.get("token") user_1 = auth_register("*****@*****.**", "passwordOne", "Firstone", "Lastone") user_1_token = user_1.get("token") user_2 = auth_register("*****@*****.**", "passwordTwo", "Firsttwo", "Lasttwo") user_2_token = user_2.get("token") channel1 = channels_create(user_1_token, "channel1", True) channel_join(user_2_token, channel1.get("channel_id")) channel_list = channels_listall(valid_viewer_token).get('channels') assert channel_list[0]["channel_id"] == channel1.get("channel_id") assert len(channel_list) == 1
def test_admin_userpermission_change_empty_input(): clear() user = auth_register('*****@*****.**', '3mptyH3@dn0i', 'Ben', 'Lucas') user2 = auth_register('*****@*****.**', '(&^hbhasj', 'Kyle', 'Phantom') with pytest.raises(InputError): admin_userpermission_change('', '', '') with pytest.raises(InputError): admin_userpermission_change(user['token'], '', '') with pytest.raises(InputError): admin_userpermission_change('', 12, '') with pytest.raises(InputError): admin_userpermission_change('', '', 1) with pytest.raises(InputError): admin_userpermission_change('', 12, 1) with pytest.raises(InputError): admin_userpermission_change(user['token'], '', 1) with pytest.raises(InputError): admin_userpermission_change(user['token'], user2['u_id'], '')
def test_channel_removeowner_invalidchannelid(): ''' Test case when attempting to remove someone as owner using an invalid channel_id ''' clear() #Registering a user register = auth_register('*****@*****.**', '123abc!@#', 'Hayden', 'Everest', None) #Storing token generated from registration process in a variable for easy access owner_token = register['token'] #Registering another user register1 = auth_register('*****@*****.**', '123abc!@#', 'Jordan', 'Fitch', None) #Storing u_id generated from registration process in a variable for easy access nonowner_u_id = register1['u_id'] #Using the registered user to create a channel new_channel = channels_create(owner_token, "Testing Channel", True) #Storing channel_id generated from channel creation in a variable for easy access channel_id = new_channel['channel_id'] with pytest.raises(InputError): channel_removeowner(owner_token, channel_id + 100, nonowner_u_id) clear()
def test_standup_send_single_message(): ''' Test that a single message collected during the standup period is sent afterwards ''' clear() user = auth_register("*****@*****.**", "password", "Firstname", "Lastname") channel = channels_create(user['token'], "Channel", True) standup_start(user['token'], channel['channel_id'], 1) standup_send(user['token'], channel['channel_id'], "message") time.sleep(2) check = search(user['token'], "message") assert len(check['messages']) == 1 assert check['messages'][0]['message'] == "firstnamelastname: message"
def test_taken_handle(): ''' Two users register and try to change to the same valid handle. ''' clear() user1 = auth_register('*****@*****.**', 'p@ssw0rd', 'Apple', 'Appleson') user2 = auth_register('*****@*****.**', 'password', 'Orange', 'Orangeson') # user1 changes handle to hello world user_profile_sethandle(user1['token'], 'hello world') user_profile(user1['token'], user1['u_id']) # user2 tries to also change to hello world with pytest.raises(InputError): user_profile_sethandle(user2['token'], 'hello world') # user1 changes handle again user_profile_sethandle(user2['token'], 'goodbye world') user_profile(user2['token'], user2['u_id']) with pytest.raises(InputError): user_profile_sethandle(user1['token'], 'goodbye world')
def test_message_react_message_already_reacted(): ''' test that an InputError is raised when a user reacts to a message that they have already reacted to ''' other.clear() owner = auth.auth_register("*****@*****.**", "password", "John", "Smith") channel_1 = channels.channels_create(owner['token'], "channel_1", True) message_sent = message.message_send(owner['token'], channel_1['channel_id'], 'owner message') message.message_react(owner['token'], message_sent['message_id'], 1) with pytest.raises(error.InputError): message.message_react(owner['token'], message_sent['message_id'], 1)
def test_admin_userpermission_change_invalid_user_id(): ''' Test that an InputError is raised when admin_userpermission_change is given a u_id that does not refer to a valid user ''' clear() f_owner = auth_register('*****@*****.**', 'password', 'Bob', 'Bob') with pytest.raises(InputError): admin_userpermission_change(f_owner['token'], f_owner['u_id'] + 1, 2) with pytest.raises(InputError): admin_userpermission_change(f_owner['token'], f_owner['u_id'] + 100, 2) with pytest.raises(InputError): admin_userpermission_change(f_owner['token'], f_owner['u_id'] - 13, 2) with pytest.raises(InputError): admin_userpermission_change(f_owner['token'], f_owner['u_id'] - 100, 2)
def test_message_send(): ''' tests that message_send is working ''' other.clear() owner = auth.auth_register("*****@*****.**", "password", "Homer", "Simpson") channel_1 = channels.channels_create(owner['token'], "channel_1", True) message.message_send(owner['token'], channel_1['channel_id'], 'this is the first test message') messages = channel.channel_messages(owner['token'], channel_1['channel_id'], 0) assert messages['messages'][0][ 'message'] == 'this is the first test message'
def test_channel_remove_member(channel1): """ Removes member from channel, returns nothing """ channel_id = channel1["channel_id"] user = data.get_user_info(1) data.channel_remove_member(channel_id, user["u_id"]) assert data.check_user_in_channel(channel_id, user["u_id"]) == False user2 = auth.auth_register("*****@*****.**", "google", "Alphabet", "Gamma") channel.channel_join(user2["token"], channel_id) data.channel_remove_member(channel_id, user2["u_id"]) assert data.check_user_in_channel(channel_id, user2["u_id"]) == False other.clear()
def test_channel_messages(): ''' Tests for channel_messages ''' clear() #Creating users to create channels user1 = auth_register("*****@*****.**", "user1pass", "user1", "last1", None) user2 = auth_register("*****@*****.**", "user2pass", "user2", "last2", None) token1 = user1['token'] token2 = user2['token'] #creating channels ch_id1 = channels_create(token1, "aGreatChannel", True)['channel_id'] ch_id2 = channels_create(token2, "yetAnotherChannel", False)['channel_id'] with pytest.raises(InputError): #test for invalid channel_id channel_messages(token1, 50, 0) #test for invalid start value channel_messages(token1, ch_id1, 3) with pytest.raises(AccessError): #test for user sending message to channel they are not a member of channel_messages(token1, ch_id2, 0)
def test_users_all_one_user(): workspace_reset() user_ef = auth_register( "*****@*****.**", "12345687", "Edward", "Frankenstein") assert users_all(user_ef["token"])["users"] == [ { 'u_id': user_ef["u_id"], 'email': '*****@*****.**', 'name_first': 'Edward', 'name_last': 'Frankenstein', 'handle_str': 'edwardfrankenstein', "profile_img_url": "" } ]
def test_users_all_users_remain_when_logout(): workspace_reset() user_gh = auth_register("*****@*****.**", "ihaveadream", "Gregory", "Heidelberg") user_ef = auth_register( "*****@*****.**", "12345687", "Edward", "Frankenstein") user_ij = auth_register( "*****@*****.**", "stretchy0urh4mstrinG5thr1c3", "Ian", "Jacobs") auth_logout(user_ef["token"]) assert users_all(user_ij["token"])["users"] == [ { 'u_id': user_gh["u_id"], 'email': '*****@*****.**', 'name_first': 'Gregory', 'name_last': 'Heidelberg', 'handle_str': 'gregoryheidelberg', "profile_img_url": "" }, { 'u_id': user_ef["u_id"], 'email': '*****@*****.**', 'name_first': 'Edward', 'name_last': 'Frankenstein', 'handle_str': 'edwardfrankenstein', "profile_img_url": "" }, { 'u_id': user_ij["u_id"], 'email': '*****@*****.**', 'name_first': 'Ian', 'name_last': 'Jacobs', 'handle_str': 'ianjacobs', "profile_img_url": "" } ]
def test_standup_send_notinstandup(): clear() #Registering a user register = auth_register('*****@*****.**', '123abc!@#', 'Hayden', 'Everest', None) #Storing token generated from registration process in a variable for easy access creator_token = register['token'] #Using the registered user to create a channel new_channel = channels_create(creator_token, "Testing Channel", True) #Storing channel_id generated from channel creation in a variable for easy access channel_id = new_channel['channel_id'] with pytest.raises(InputError): #Channel not in standup standup_send(creator_token, channel_id, 'h')
def test_invalid_profile_setemail(): # Register some valid users with valid emails: # Then check invalid user1 = auth_register('*****@*****.**', 'Em4il123', 'Emailia', 'Compose') token = user1['token'] with pytest.raises(InputError) as e: user_profile_setemail(token, 'Thisisntanemail.com') with pytest.raises(InputError) as e: user_profile_setemail(token, '*****@*****.**') with pytest.raises(InputError) as e: user_profile_setemail(token, 'UNeverSleepWell.com') user2 = auth_register('*****@*****.**', 'Abdullah1', 'Abdul', 'Ahmed') token = user2['token'] with pytest.raises(InputError) as e: user_profile_setemail(token, 'ThisisntanemailYouGenius.com') with pytest.raises(InputError) as e: user_profile_setemail(token, 'microsoft.com') with pytest.raises(InputError) as e: user_profile_setemail(token, '*****@*****.**') user3 = auth_register('*****@*****.**', 'Jeffrey', 'Mynameis', 'Mypassword') token = user3['token'] with pytest.raises(InputError) as e: user_profile_setemail(token, 'ThisisntanemailYouGenius.com') with pytest.raises(InputError) as e: user_profile_setemail(token, '*****@*****.**') with pytest.raises(InputError) as e: user_profile_setemail(token, '*****@*****.**')
def test_message_remove_multiple_channels(): ''' Test that message remove works when a user is in multiple channels ''' other.clear() owner = auth.auth_register("*****@*****.**", "password", "Homer", "Simpson") user = auth.auth_register("*****@*****.**", "password", "Bart", "Simpson") channels.channels_create(owner['token'], "channel_1", True) channel_2 = channels.channels_create(owner['token'], "channel_2", True) channel.channel_join(user['token'], channel_2['channel_id']) message.message_send(user['token'], channel_2['channel_id'], 'test message 1') message_to_remove = message.message_send(user['token'], channel_2['channel_id'], 'test message 2') message.message_remove(user['token'], message_to_remove['message_id']) messages = channel.channel_messages(user['token'], channel_2['channel_id'], 0) assert messages['messages'][0]['message'] == 'test message 1' assert messages['start'] == 0 assert messages['end'] == -1 assert len(messages['messages']) == 1
def test_users_all_simple(): user_info = auth.auth_register('m@gmail', 'sadsad', 'name', 'lastname') # Giving all the users' profile details assert other.users_all(user_info['token']) == { 'users': [ { 'u_id': 1, 'email': 'm@gmail', 'name_first': 'name', 'name_last': 'lastname', 'handle_str': 'namelastname', } ], }
def test_message_remove(): ''' Test that message_remove removes the specified message in the channel ''' other.clear() owner = auth.auth_register("*****@*****.**", "password", "Homer", "Simpson") channel_1 = channels.channels_create(owner['token'], "channel_1", True) message_1 = message.message_send(owner['token'], channel_1['channel_id'], 'this is the first test message') message.message_remove(owner['token'], message_1['message_id']) messages = channel.channel_messages(owner['token'], channel_1['channel_id'], 0) assert messages['messages'] == []
def test_standup_active_invalid_inputs(): ''' Test basic error raising from invalid inputs ''' clear() user = auth_register("*****@*****.**", "password", "Firstname", "Lastname") channel = channels_create(user['token'], "Channel", True) # invalid token raises AccessError with pytest.raises(AccessError): standup_active("notToken", channel['channel_id']) # invalid channel_id raises InputError with pytest.raises(InputError): standup_active(user['token'], -1)