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")
