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_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_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_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_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_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_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_unit_auth_register():
json_functions.data_test_initiate()
# Testing for the first user who registers with auth_register
data = json_functions.getData()
print(data)
authRegisterDic = f_auth_register.auth_register("*****@*****.**",
"valid1password",
"first1name", "last1name")
token_one = authRegisterDic['token']
u_id_one = authRegisterDic['u_id']
json_functions
# Checking that the data values have been input correctly
# Checking that the first user's permission is set to Owner (permission_id = 1)
user_found = False
data = json_functions.getData()
for user in data['users']:
if user['email'] == "*****@*****.**":
user_found = True
assert user['token'] == token_one
assert user['u_id'] == u_id_one
assert user['permission_id'] == 1
if user_found == False:
raise ValueError('Error, user not found in data')
# Testing for the second user who registers with auth_register
authRegisterDicTwo = f_auth_register.auth_register("*****@*****.**",
"valid2password",
"first2name",
"last2name")
token_two = authRegisterDicTwo['token']
u_id_two = authRegisterDicTwo['u_id']
# Checking that the data values have been input correctly
# Checking that the first user's permission is set to User (permission_id = 3)
user_found = False
data = json_functions.getData()
for user in data['users']:
if user['email'] == '*****@*****.**':
user_found = True
assert user['token'] == token_two
assert user['u_id'] == u_id_two
assert user['permission_id'] == 3
if user_found == False:
raise ValueError('Error, user not found in data')
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_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_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():
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_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_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_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_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_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_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' : []}
def test_message_pin_bad():
jsonClean()
# SETUP BEGIN
authRegisterDic = auth_register("*****@*****.**", "valid70password",
"first70name", "last70name")
token = authRegisterDic['token']
u_id = authRegisterDic['u_id']
channelsCreateDic = channels_create(token, "validchannel", True)
channel_id = channelsCreateDic['channel_id']
authRegisterDicOne = auth_register("*****@*****.**", "valid71password",
"first71name", "last71name")
token_one = authRegisterDicOne['token']
u_id_one = authRegisterDicOne['u_id']
channel_join(token_one, channel_id)
authRegisterDicTwo = auth_register("*****@*****.**", "valid72password",
"first72name", "last72name")
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
with pytest.raises(ValueError):
# Testing function with user who isn't admin
message_unpin(token_one, message_id)
# Testing function with invalid message_id
message_unpin(token, "invalidmessage_id")
# Testing function with user who isn't part of the channel
message_unpin(token_two, message_id)
message_unpin(token, message_id)
with pytest.raises(ValueError):
# Testing function with already unpinned message_id
message_unpin(token, message_id)
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_message_react():
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)
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"]
# Assuming 123 is valid react_id
react_id = 123
# SETUP END
assert message_react(token, message_id, react_id) == {}
# Testing two users can react laugh one message
assert message_react(token_one, message_id, react_id) == {}
with pytest.raises(ValueError):
# Testing function can't react the message for a second time
message_react(token, message_id, react_id)
# Testing function can unreact the message
assert message_unreact(token, message_id, react_id) == {}
