def test_channel_invite_bad(): # SET UP BEGIN jsonClean() authRegisterDic = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] authRegisterDicOne = auth_register("*****@*****.**", "validpassword1", "firstname1", "lastname1") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] channelsCreateDicOne = channels_create(token_one, "validchannel1", True) channel_id_one = channelsCreateDicOne['channel_id'] authRegisterDicTwo = auth_register("*****@*****.**", "validpassword2", "firstname2", "lastname2") token_two = authRegisterDicTwo['token'] u_id_two = authRegisterDicTwo['u_id'] # SETUP END with pytest.raises(ValueError): # Testing function with invalid channel_id channel_invite(token, "invalidchannel_id", u_id_one) # Testing function with channel_id which the authorised user isn't a member of channel_invite(token, channel_id_one, u_id_two) # Testing function with an invalid u_id channel_invite(token, channel_id, "invalidu_id") auth_logout(token_one) with pytest.raises(ValueError): # Testing function with invalid token channel_invite(token_one, channel_id_one, u_id_two)
def test_auth_login(): jsonClean() # SETUP BEGIN authRegisterDic = auth_register("*****@*****.**", "valid10password", "first10name", "last10name") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] # SETUP END ''' with pytest.raises(ValueError): # Testing function with account which hasn't been logged out auth_login("*****@*****.**", "valid10password") ''' # Testing function with account which has been logged out auth_logout(token) authLoginDic = auth_login("*****@*****.**", "valid10password") token = authLoginDic['token'] u_id = authLoginDic['u_id'] data = getData() # checking the token matches the token in the database token_valid = False for users in data['users']: if u_id == users['u_id']: if users['token'] == token: token_valid = True if token_valid == False: raise ValueError(f"Login unsuccessful...\n") # Testing if we can logout using new token auth_logout(token)
def test_auth_logout(): jsonClean() # SETUP BEGIN authRegisterDic = auth_register("*****@*****.**", "valid13password", "first13name", "last13name") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] # SETUP END with pytest.raises(ValueError): # Testing login function with user which hasn't been logged out auth_login("*****@*****.**", "valid13password") # auth_login does not check to see if the user is already logged in! auth_logout(token) data = getData() # checking that the token is invalidated token_invalidated = False for users in data['users']: if u_id == users['u_id']: if users['token'] == None: token_invalidated = True if token_invalidated == False: raise ValueError(f"Logout unsuccessful...\n") # Testing login function with logged out user to check he's succesfully logged out auth_login("*****@*****.**", "valid13password") auth_logout(token) # Testing logout function with a logged out user with pytest.raises(ValueError): assert auth_logout(token) == {}
def test_user_profile_sethandle(): jsonClean() # SETUP BEGIN handle_str_good = "thisismorethantwentycharacters" handle_str_bad = "goodhandle" handle_str_max = "hithisis20characters" validAuthRegisterDic = auth_register("*****@*****.**", "validpassword", "Richard", "Jiang") token = validAuthRegisterDic['token'] u_id = validAuthRegisterDic['u_id'] invalidAuthRegisterDicTwo = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") invalid_token = invalidAuthRegisterDicTwo['token'] invalid_u_id = invalidAuthRegisterDicTwo['u_id'] # Invalidates token auth_logout(invalid_token) # SETUP END # Testing successful run (default case) assert user_profile_sethandle(token, handle_str_good) == {} # Testing maximum case of handle_str assert user_profile_sethandle(token, handle_str_max) == {} with pytest.raises(ValueError): # Testing good token, with bad handle_str user_profile_sethandle(token, handle_str_bad) # Testing bad token, with good handle_str user_profile_sethandle(invalid_token, handle_str_good) # Testing both bad token and bad handle_str user_profile_sethandle(invalid_token, handle_str_bad)
def test_standup_start(): jsonClean() # Valid channel ID authRegisterDic = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] createValidChannelDict = channels_create(token, "validchannel", True) channel_id = createValidChannelDict["channel_id"] time_finish = "19:15/02/10/2019" # Invalid channel ID registerInvalidUserDict = auth_register("*****@*****.**", "password", "Thom", "Browne") invalid_token = registerInvalidUserDict["token"] invalid_uid = registerInvalidUserDict["u_id"] createInvalidChannelDict = channels_create(invalid_token, "invalidchannel", True) invalid_channelid = createInvalidChannelDict["channel_id"] assert standup_start(token, channel_id) == {time_finish} with pytest.raises(ValueError): # Testing function with invalid channel_id standup_start(token, invalid_channelid) # Testing function with invalid token standup_start(invalid_token, channelid)
def test_channels_listall_bad(): jsonClean() # SET UP BEGIN authRegisterDic = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] channelsCreateDicOne = channels_create(token, "validchannel1", False) channel_id_one = channelsCreateDicOne['channel_id'] channelsCreateDicTwo = channels_create(token, "validchannel2", True) channel_id_two = channelsCreateDicTwo['channel_id'] channelsCreateDicThree = channels_create(token, "validchannel3", True) channel_id_three = channelsCreateDicThree['channel_id'] # SETUP END # Invalidating token auth_logout(token) with pytest.raises(ValueError): # Testing function using invalid token channels_list(token)
def test_channel_leave_bad(): jsonClean() # SET UP BEGIN authRegisterDic = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] authRegisterDicOne = auth_register("*****@*****.**", "validpassword1", "firstname1", "lastname1") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] authRegisterDicTwo = auth_register("*****@*****.**", "validpassword2", "firstname2", "lastname2") token_two = authRegisterDicTwo['token'] u_id_two = authRegisterDicTwo['u_id'] # SETUP END channel_join(token_one, channel_id) with pytest.raises(ValueError): # Testing function using invalid channel_id channel_leave(token_one, "invalidchannel_id") # Testing function on user who isn't part of the channel channel_leave(token_two, channel_id) auth_logout(token_one) with pytest.raises(ValueError): # Testing function using invalid token channel_leave(token_one, channel_id)
def test_channel_join_bad(): jsonClean() # SET UP BEGIN authRegisterDic = auth_register("*****@*****.**", "validpassword", "first10name", "last10name") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", False) channel_id = channelsCreateDic['channel_id'] authRegisterDicOne = auth_register("*****@*****.**", "validpassword1", "first20name1", "last20name1") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] # SETUP END with pytest.raises(ValueError): # Testing function with invalid channel_id channel_join(token_one, "invalidchannel_id") # Testing function with unauthorised token when channel is private channel_join(token_one, channel_id) # Invalidate token auth_logout(token_one) with pytest.raises(ValueError): # Testing function with invalid token channel_join(token_one, channel_id)
def test_message_pin(): jsonClean() # SETUP BEGIN authRegisterDic = auth_register("*****@*****.**", "valid60password", "first60name", "last60name") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] authRegisterDicOne = auth_register("*****@*****.**", "valid61password", "first61name", "last61name") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] message_send(token, channel_id, "validmessage") channelMessagesDic = channel_messages(token, channel_id, 0) message_list = channelMessagesDic["messages"] message_dic = message_list[0] message_id = message_dic["message_id"] # SETUP END message_pin(token, message_id) with pytest.raises(ValueError): message_pin(token, message_id) assert message_unpin(token, message_id) == {} # Testing message_pin to check the message was successfully unpinned message_pin(token, message_id)
def test_channels_create_bad(): jsonClean() # SETUP BEGIN authRegisterDic = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] # SETUP END with pytest.raises(ValueError): # Testing function with public channel_name which is too long channels_create(token, "this name is way too long so it will cause an error", True) # Testing function with private channel name which is too long channels_create(token, "this name is way too long so it will cause an error", False) auth_logout(token) with pytest.raises(ValueError): # Testing function with invalid token to create public channel channels_create(token, "validchannel", True) # Testing function with invalid token to create private channel channels_create(token, "validchannel", False)
def test_channels_create(): jsonClean() # SETUP BEGIN authRegisterDic = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] # SETUP END channels_create(token, "validchannel", True) channel_found = False data = getData() for channels in data['channels']: if channels['channel_name'] == 'validchannel': channel_found = True assert channel_found == True assert channels_create(token, "validchannel1", False) == { 'channel_id': "validchannel1" } channel2_found = False data = getData() for channels in data['channels']: if channels['channel_name'] == 'validchannel1': channel2_found = True assert channel2_found == True
def test_user_profile(): jsonClean() # SETUP BEGIN validAuthRegisterDic = auth_register("*****@*****.**", "valid16password", "first16name", "last16name") goodtoken = validAuthRegisterDic['token'] goodu_id = validAuthRegisterDic['u_id'] invalidAuthRegisterDic = auth_register("*****@*****.**", "valid17password", "first17name", "last17name") invalid_token = invalidAuthRegisterDic['token'] auth_logout(invalid_token) #Creates an Invalid Token badu_id = "invaliduserid" # SETUP END assert user_profile(goodtoken, goodu_id) == { 'email': "*****@*****.**", 'first_name': "first16name", 'last_name': "last16name", 'handle_str': "first16namelast16name" } # In Iteration 1, auth_register doesn't let you set a handle_str... with pytest.raises(ValueError): # Testing a bad token with a good user_id user_profile(invalid_token, goodu_id) # Testing a good token with a bad user_id auth_profile(invalid_token, badu_id) # Testing both a bad token and bad user_id auth_profile(invalid_token, badu_id)
def test_user_profile_setemail(): jsonClean() # SETUP BEGIN validAuthRegisterDic = auth_register("*****@*****.**", "valid20password", "first20name", "last20name") token = validAuthRegisterDic['token'] u_id = validAuthRegisterDic['u_id'] email_good = "*****@*****.**" email_good_new = "*****@*****.**" invalidAuthRegisterDicTwo = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") invalid_token = invalidAuthRegisterDicTwo['token'] invalid_u_id = invalidAuthRegisterDicTwo['u_id'] email_bad = "bademail" auth_logout(invalid_token) # SETUP END # Default testing assert user_profile_setemail(token, email_good) == {} with pytest.raises(ValueError): # Testing user_profile_setemail with invalid token user_profile_setemail(invalid_token, email_good_new) # Testing user_profile_setemail with invalid token user_profile_setemail(token, email_bad) # Testing user_profile_setemail with invalid token and bad email user_profile_setemail(invalid_token, email_bad) # Testing user_profile_setemail with valid token and error email user_profile_setemail(invalid_token, email_bad)
def test_message_sendlater(): jsonClean() # SETUP BEGIN # Generate a valid user registerValidUserDict = auth_register("*****@*****.**", "password", "Thom", "Browne") token = registerValidUserDict["token"] u_id = registerValidUserDict["u_id"] createValidChannelDict = channels_create(token, "validchannel", True) channel_id = createValidChannelDict["channel_id"] channel_invite(token, channel_id, u_id) message = "I Heart Thom Browne" timesent = present + timedelta(minutes=1) + tdelta # Generate an invalid user registerInvalidUserDict = auth_register("*****@*****.**", "password", "Thom", "Browne") invalid_token = registerInvalidUserDict["token"] invalid_uid = registerValidUserDict["u_id"] createInvalidChannelDict = channels_create(invalid_token, "invalidchannel", True) invalid_channelid = createInvalidChannelDict["channel_id"] channel_invite(invalid_token, invalid_channelid, invalid_uid) invalid_message = 0 invalid_timesent = "20/10/1999" # Invalidate the invalid user auth_logout(invalid_token) # SET UP END # Asserting that the default case works message_id = message_sendlater(token, channel_id, message, timesent) time.sleep(60) data = getData() for channels in data['channels']: for messages in channels['messages']: if messages['message'] == message: assert messages['message_id'] == message_id['message_id'] # Testing that ValueError is raised when invalid parameters are passed with pytest.raises(ValueError): # Testing function with an invalid token message_sendlater(invalid_token, channel_id, message, timesent) # Testing function with an invalid channel id message_sendlater(token, invalid_channelid, message, timesent) # Testing function with an invalid message message_sendlater(token, channel_id, invalid_message, timesent) # Testing function with an invalid timesent input message_sendlater(token, channel_id, message, invalid_timesent)
def test_auth_passwordreset_request(): jsonClean() # SETUP BEGIN authRegisterDic = auth_register("*****@*****.**", "valid14password", "first14name", "last14name") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] # SETUP END # Testing function with valid email auth_passwordreset_request("*****@*****.**")
def test_message_send(): jsonClean() # SETUP BEGIN # Generate a valid user registerValidUserDict = auth_register("*****@*****.**", "valid6password", "first6name", "last6name") token = registerValidUserDict['token'] u_id = registerValidUserDict['u_id'] createValidChannelDict = channels_create(token, "validchannel", True) channel_id = createValidChannelDict['channel_id'] channel_invite(token, channel_id, u_id) message = "I Heart Hayden Smith" # Generate an invalid user registerInvalidUserDict = auth_register("*****@*****.**", "invalid6password", "invalid6firstname", "invalid6lastname") invalid_token = registerInvalidUserDict['token'] invalid_uid = registerValidUserDict['u_id'] createInvalidChannelDict = channels_create(invalid_token, "invalidchannel", True) invalid_channelid = createInvalidChannelDict['channel_id'] channel_invite(invalid_token, invalid_channelid, invalid_uid) invalid_message = 0 # Invalidate the invalid user auth_logout(invalid_token) # SETUP END # Asserting that the default case works message_id = message_send(token, channel_id, message) data = getData() for channels in data['channels']: for messages in channels['messages']: if messages['message'] == message: assert messages['message_id'] == message_id['message_id'] # Testing that ValueError is raised when invalid parameters are passed with pytest.raises(ValueError): # Testing function with an invalid token message_send(invalid_token, channel_id, message) # Testing function with an invalid channel id message_send(token, invalid_channelid, message) # Testing function with an invalid message message_send(token, channel_id, invalid_message)
def test_auth_passwordreset_request_bad(): jsonClean() # SETUP BEGIN authRegisterDic = auth_register("*****@*****.**", "valid15password", "first15name", "last15name") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] # SETUP END with pytest.raises(ValueError): # Testing function with invalid email auth_passwordreset_request("invalidemail")
def test_channel_join(): jsonClean() # SET UP BEGIN authRegisterDic = auth_register("*****@*****.**", "validpassword", "first100name", "last100name") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] authRegisterDicOne = auth_register("*****@*****.**", "validpassword1", "firstname1", "lastname1") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] # SETUP END channel_join(token_one, channel_id) # checking output matches local data base data = getData() for channels in data['channels']: if channels['channel_id'] == channel_id: assert channels['all_members'] == [{ "u_id": u_id, "name_first": "first100name", "name_last": "last100name" }, { "u_id": u_id_one, "name_first": "firstname1", "name_last": "lastname1" }] # Assuming admin isn't in all_members list since admin was specifically isn't a member assert channel_details(token, channel_id) == { "name": "validchannel", "owner_members": [{ "u_id": u_id, "name_first": "first100name", "name_last": "last100name" }], "all_members": [{ "u_id": u_id, "name_first": "first100name", "name_last": "last100name" }, { "u_id": u_id_one, "name_first": "firstname1", "name_last": "lastname1" }] }
def test_message_remove(): jsonClean() # SETUP BEGIN # Generate a valid user registerValidUserDict = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = registerValidUserDict["token"] u_id = registerValidUserDict["u_id"] createValidChannelDict = channels_create(token, "validchannel", True) channel_id = createValidChannelDict["channel_id"] channel_invite(token, channel_id, u_id) message_send(token, channel_id, "Hi") message_send(token, channel_id, "My name is") message_send(token, channel_id, "Thom Browne") channelValidMessagesDict = channel_messages(token, channel_id, 0) message_list = channelValidMessagesDict["messages"] message_dict = message_list[0] message_id = message_dict["message_id"] # Generate an invalid user registerInvalidUserDict = auth_register("*****@*****.**", "invalidpassword", "invalidfirstname", "invalidlastname") invalid_token = registerInvalidUserDict["token"] invalid_uid = registerValidUserDict["u_id"] createInvalidChannelDict = channels_create(invalid_token, "invalidchannel", True) invalid_channelid = createInvalidChannelDict["channel_id"] channel_invite(invalid_token, invalid_channelid, invalid_uid) message_send(invalid_token, channel_id, "iH") message_send(invalid_token, channel_id, "si eman yM") message_send(invalid_token, channel_id, "enworB mohT") channelInvalidMessagesDict = channel_messages(invalid_token, invalid_channelid, 1) invalid_messagelist = channelValidMessagesDict["messages"] invalid_messagedict = invalid_messagelist[1] invalid_messageid = invalid_messagedict["message_id"] # Invalidate the invalid user auth_logout(invalid_token) # SETUP END # Asserting that the default case works assert remove_message(token, message_id) == {} # Testing that ValueError is raised when invalid parameters are passed with pytest.raises(ValueError): # Testing function with an invalid token remove_message(invalid_token, message_id) # Testing function with an invalid message id remove_message(valid_token, invalid_messageid)
def test_message_unreact_bad(): jsonClean() # SETUP BEGIN authRegisterDic = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] authRegisterDicOne = auth_register("*****@*****.**", "validpassword1", "firstname1", "lastname1") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] channel_join(token_one, channel_id) authRegisterDicTwo = auth_register("*****@*****.**", "validpassword2", "firstname2", "lastname2") token_two = authRegisterDicTwo['token'] u_id_two = authRegisterDicTwo['u_id'] message_send(token, channel_id, "validmessage") channelMessagesDic = channel_messages(token, channel_id, 0) message_list = channelMessagesDic["messages"] message_dic = message_list[0] message_id = message_dic["message_id"] # SETUP END message_react(token, message_id, 1) with pytest.raises(ValueError): # Testing function with user who isn't admin message_unreact(token_one, message_id, 1) # Testing function with invalid message_id message_unreact(token, "invalidmessage_id", 1) # Testing function with user who isn't part of the channel message_unreact(token_two, message_id, react_id) # Testing function with invalid react_id message_unreact(token, message_id, "invalidreact_id") message_unreact(token, message_id, 1) with pytest.raises(ValueError): # Testing function with already unreacted message_id message_unreact(token, message_id, 1) message_react(token, message_id, react_id) auth_logout(token) with pytest.raises(ValueError): # Testing function with invalid token message_unreact(token, message_id, react_id)
def test_channels_list_bad(): jsonClean() # SETUP BEGIN authRegisterDic = auth_register("invalidemail", "invalidpassword", "firstname", "lastname") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] # SETUP END auth_logout(token) with pytest.raises(ValueError): # Testing function using invalid token channels_list(token)
def test_admin_userperm_change(): jsonClean() # SETUP BEGIN # Generate a valid user registerValidUserDict = auth_register("*****@*****.**", "password", "Thom", "Browne") token = registerValidUserDict["token"] u_id = registerValidUserDict["u_id"] permission_id = 1 # Generate a valid user registerValidUserDictOne = auth_register("*****@*****.**", "password", "first30name", "last30name") token_one = registerValidUserDictOne["token"] u_id_one = registerValidUserDictOne["u_id"] # Generate an invalid user registerInvalidUserDictTwo = auth_register("*****@*****.**", "feelspecial", "Hwang", "Yeji") invalid_token = registerInvalidUserDictTwo["token"] invalid_uid = registerInvalidUserDictTwo["u_id"] invalid_permission_id = "a" # Invalidate the invalid user auth_logout(invalid_token) # SETUP END # Asserting that the default case works assert admin_userperm_change("CIMICTOP1012345abcd", u_id_one, permission_id) == {} # Testing that ValueError is raised when invalid parameters are passed with pytest.raises(ValueError): # Testing function with an invalid token admin_userperm_change(invalid_token, u_id, permission_id) # Testing function with an invalid u_id admin_userperm_change(token, invalid_uid, permission_id) # Testing that SystemError is raised when invalid parameters are passed with pytest.raises(ValueError): # Testing function with an invalid permission_id admin_userperm_change(token, u_id, invalid_permission_id)
def test_user_profile_setname(): jsonClean() # SETUP BEGIN name_first_bad = "exam1exam2exam3exam4exam5exam6exam7exam8exam9exam10" name_last_bad = "exam1exam2exam3exam4exam5exam6exam7exam8exam9exam10" name_first_good = "Richard" name_last_good = "Jiang" validAuthRegisterDic = auth_register("*****@*****.**", "validpassword", "Richard", "Jiang") token = validAuthRegisterDic['token'] u_id = validAuthRegisterDic['u_id'] invalidAuthRegisterDicTwo = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") invalid_token = invalidAuthRegisterDicTwo['token'] invalid_u_id = invalidAuthRegisterDicTwo['u_id'] # Invalidates token auth_logout(invalid_token) # SETUP END # Testing the default case assert user_profile_setname(token, name_first_good, name_last_good) == {} # checking name is changed in local data base name_set = False data = getData() for users in data['users']: if users['token'] == token: if users['first_name'] == name_first_good: if users['last_name'] == name_last_good: name_set = True if name_set == False: raise ValueError(f"Name was unable to be set...\n") with pytest.raises(ValueError): # Testing user_profile_setname with bad name_first user_profile_setname(token, name_first_bad, name_last_good) # Testing user_profile_setname with bad name_last user_profile_setname(token, name_first_good, name_last_bad) # Testing user_profile_setname with both bad name_first and name_last user_profile_setname(token, name_first_bad, name_last_bad) # Testing user_profile_setname with a bad token user_profile_setname(invalid_token, name_first_good, name_last_good)
def test_channel_addowner_bad(): jsonClean() # SET UP BEGIN authRegisterDic = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] authRegisterDicOne = auth_register("*****@*****.**", "validpassword1", "firstname1", "lastname1") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] authRegisterDicTwo = auth_register("*****@*****.**", "validpassword2", "firstname2", "lastname2") token_two = authRegisterDicTwo['token'] u_id_two = authRegisterDicTwo['u_id'] authRegisterDicThree = auth_register("*****@*****.**", "validpassword3", "firstname3", "lastname3") token_three = authRegisterDicThree['token'] u_id_three = authRegisterDicThree['u_id'] authRegisterDicFour = auth_register("*****@*****.**", "validpassword4", "firstname4", "lastname4") token_four = authRegisterDicFour['token'] u_id_four = authRegisterDicFour['u_id'] # SETUP END with pytest.raises(ValueError): # Testing function with invalid channel_id channel_addowner(token, "invalidchannel_id", u_id_one) channel_addowner(token, channel_id, u_id_one) with pytest.raises(ValueError): # Testing function on a user who's already an owner channel_addowner(token, "invalidchannel_id", u_id_one) # Testing function with a user who isn't an owner channel_addowner(token_two, channel_id, u_id_three) auth_logout(token) with pytest.raises(ValueError): # Testing function on an invalid token channel_addowner(token, channel_id, u_id_four)
def test_message_edit(): # SETUP BEGIN jsonClean() # Token creates the channel so it should be the owner registerValidUserDict = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = registerValidUserDict["token"] u_id = registerValidUserDict["u_id"] createValidChannelDict = channels_create(token, "validchannel", True) channel_id = createValidChannelDict["channel_id"] message_send(token, channel_id, "Hi") message_send(token, channel_id, "My name is") message_send(token, channel_id, "Thom Browne") channelValidMessagesDict = channel_messages(token, channel_id, 0) message_list = channelValidMessagesDict["messages"] message_dict = message_list[0] message_id = message_dict["message_id"] # A member in the channel authRegisterDicOne = auth_register("*****@*****.**", "validpassword2", "firstname2", "lastname2") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] channel_invite(token, channel_id, u_id_one) message_send(token_one, channel_id, "iH") message_send(token_one, channel_id, "si eman yM") message_send(token_one, channel_id, "enworB mohT") channelInvalidMessagesDict = channel_messages(token_one, channel_id, 1) invalid_messagelist = channelValidMessagesDict["messages"] invalid_messagedict = invalid_messagelist[1] invalid_messageid = invalid_messagedict["message_id"] # SETUP END # Asserting that the default case works assert message_edit(token, message_id, message_list[0]) == {} # Testing that ValueError is raised when invalid parameters are passed with pytest.raises(ValueError): # Testing function with an invalid token message_edit(token_one, message_id, message_list[0]) # Testing function with an invalid message id message_edit(token_one, invalid_messageid, message_list[1])
def test_auth_passwordreset_reset(): jsonClean() # SETUP BEGIN authRegisterDic = auth_register("valid@16email,com", "valid16password", "first16name", "last16name") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] # SETUP END auth_passwordreset_request("*****@*****.**") # setting password auth_passwordreset_reset("first16namelast16name", "new_password") # checking I can log in with the new password auth_login("*****@*****.**", "new_password")
def test_auth_passwordreset_reset_bad(): jsonClean() # SETUP BEGIN authRegisterDic = auth_register("*****@*****.**", "valid17password", "first17name", "last17name") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] # SETUP END auth_passwordreset_request("*****@*****.**") with pytest.raises(ValueError): # Testing function with invalid reset code auth_passwordreset_reset("invalid_reset_code", "new_password") # Testing function with invalid password auth_passwordreset_reset("reset_code", "ivp")
def test_channel_invite(): jsonClean() # SET UP BEGIN authRegisterDic = auth_register("*****@*****.**", "validpassword", "first6name", "last6name") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] authRegisterDicOne = auth_register("*****@*****.**", "validpassword1", "first8name1", "last8name1") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] # SETUP END channel_invite(token, channel_id, u_id_one) # Asserting that the invited user is now a member of the channel assert channel_details(token_one, channel_id) == {"name": "validchannel", "owner_members": [{"u_id": u_id, "name_first": "first6name", "name_last": "last6name"}], "all_members": [{"u_id": u_id, "name_first": "first6name", "name_last": "last6name"}, {"u_id": u_id_one, "name_first": "first8name1", "name_last": "last8name1"}]} # Testing channel_leave to check that he's a member of the channel channel_leave(token_one, channel_id)
def test_standup_send(): jsonClean() # Generate a valid user registerValidUserDict = auth_register("*****@*****.**", "feelspecial", "Hwang", "Yeji") token = registerValidUserDict["token"] u_id = registerValidUserDict["u_id"] createValidChannelDict = channels_create(token, "validchannel", True) channel_id = createValidChannelDict["channel_id"] message = "I Heart Hwang Yeji" message_list = createValidChannelDict['messages'] message_dict = message_list[0] message_id = message_dict["message_id"] time = "19:16/02/10" # Generate an invalid user registerInvalidUserDict = auth_register("*****@*****.**", "password", "Kang", "Daniel") invalid_token = registerInvalidUserDict["token"] invalid_uid = registerInvalidUserDict["u_id"] createInvalidChannelDict = channels_create(invalid_token, "invalidchannel", True) invalid_channelid = createInvalidChannelDict["channel_id"] channel_invite(invalid_token, invalid_channelid, invalid_uid) invalid_message = 0 # Asserting that the default case works assert standup_send(token, channel_id, message) == {} # Testing that ValueError is raised when invalid parameters are passed with pytest.raises(ValueError): # Testing function with an invalid token standup_send(invalid_token, channel_id, message) # Testing function with an invalid channel id standup_send(token, invalid_channelid, message) # Testing function with an invalid message standup_send(token, channel_id, invalid_message)
def test_channels_list(): jsonClean() # SETUP BEGIN authRegisterDic = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] authRegisterDicOne = auth_register("*****@*****.**", "validpassword1", "firstname1", "lastname1") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] # SETUP END # Testing function using authorised user assert channels_list(token) == [{'channels': {channel_id: "validchannel"}}] for channels in data['channels']: assert channels == {'channel_id' : channel_id, 'channel_name' : "validchannel", 'is_public' : True, 'owner_members' : [{'u_id' : u_id, 'name_first' : name_first,'name_last' : name_last}], 'all_members' : [{'u_id' : u_id, 'name_first' : name_first,'name_last' : name_last}], 'messages' : []}