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_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_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_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_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_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_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_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_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_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_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_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_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 wrap_auth_logout(): auth_logout(request.form.get('token')) return json.dumps({})
def test_search(): jsonClean() # SETUP BEGIN # User One validAuthRegisterDic = auth_register("*****@*****.**", "valid30password", "first30name", "last30name") token = validAuthRegisterDic['token'] u_id = validAuthRegisterDic['u_id'] # User Two validAuthRegisterDicOne = auth_register("*****@*****.**", "valid31password", "first31name", "last31name") token_one = validAuthRegisterDicOne['token'] u_id_one = validAuthRegisterDicOne['u_id'] # False User Three invalidAuthRegisterDic = auth_register("*****@*****.**", "valid32password", "first32name", "last32name") invalid_token = invalidAuthRegisterDic['token'] # Creates an Invalid Token auth_logout(invalid_token) # Create a channel channel_id_dic = channels_create(token, "Channel Nine", True) channel_id = channel_id_dic['channel_id'] # Invite the member channel_invite(token, channel_id, u_id_one) # Send the messages message_send(token_one, channel_id, "Safe and secure society") message_send(token, channel_id, "Hello") message_send(token_one, channel_id, "Hellomydude") message_send(token, channel_id, "Hellomyman") message_send(token, channel_id, "Seriously cool") message_send(token_one, channel_id, "Absolutely astonishing") message_send(token, channel_id, "Congratulations on the role!") message_send(token_one, channel_id, "Happy work anniversary!") message_send(token, channel_id, "New world. New skills.") message_send(token, channel_id, "New world") # Find the Message ID's channelMessagesDic = channel_messages(token, channel_id, 0) message_list = channelMessagesDic["messages"] message_dic = message_list[0] message_id_safe = message_dic["message_id"] message_dic_one = message_list[2] message_id_one = message_dic_one["message_id"] message_dic_two = message_list[3] message_id_two = message_dic_two["message_id"] # SETUP END # Testing for no results assert search(token, "???") == [] # Testing for one result assert search(token, "Safe") == {"message_id" : message_id_safe, "u_id" : u_id_one, "message" : "Safe and secure society", "time_created" : "19:35", "is_unread" : False} # Testing for two or more results assert search(token, "Hellomy") == [{ "message_id" : message_id_one, "u_id" : u_id_one, "message" : "Hellomydude", "time_created" : "17:35", "is_unread" : False }, { "message_id" : message_id, "u_id" : u_id, "message" : "Helloymyman", "time_created" : "18:35", "is_unread" : False }] # Testing Bad Cases with pytest.raises(ValueError): # Bad token with multiple search results search(invalid_token, "Hellomy") # Bad token with no search results search(invalid_token, "ahahahahahaha")