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_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_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_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_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_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_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_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_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_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_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_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_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_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_channels_listall():
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
# Testing function using authorised user
assert channels_listall(token) == {
'channels': [{
'channel_id': channel_id,
'name': 'validchannel'
}, {
'channel_id': channel_id_one,
'name': 'validchannel1'
}, {
'channel_id': channel_id_two,
'name': 'validchannel2'
}, {
'channel_id': channel_id_three,
'name': 'validchannel3'
}]
}
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_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_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) == {}
def test_channel_removeowner():
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
# Adding user_one as an owner
channel_addowner(token, channel_id, u_id_one)
# Removing user_one as an owner
channel_removeowner(token, channel_id, u_id_one)
# checking output matches local data base
data = getData()
for channels in data['channels']:
if channels['channel_id'] == channel_id:
assert channels['owner_members'] == [{"u_id": u_id, "name_first": "firstname", "name_last": "lastname"}]
# Calling function with recently removed owner to check he's not an owner
channel_addowner(token_one, channel_id, u_id_two)
# checking output matches local data base
data = getData()
for channels in data['channels']:
if channels['channel_id'] == channel_id:
assert channels['owner_members'] == [{"u_id": u_id, "name_first": "firstname", "name_last": "lastname"}, {"u_id": u_id_two, "name_first": "firstname2", "name_last": "lastname2"}]
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")
def wrap_channels_create():
channels_create(request.form.get('token'), request.form.get('name'),
request.form.get('is_public'))
return json.dumps({})
def test_channel_addowner():
jsonClean()
# SET UP BEGIN
authRegisterDic = auth_register("*****@*****.**", "valid9password",
"first9name", "last9name")
token = authRegisterDic['token']
u_id = authRegisterDic['u_id']
channelsCreateDic = channels_create(token, "validchannel", True)
channel_id = channelsCreateDic['channel_id']
authRegisterDicOne = auth_register("*****@*****.**", "valid6password1",
"first6name1", "last6name1")
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
with pytest.raises(ValueError):
# Testing function with member token to confirm he's not an owner
channel_addowner(token_one, channel_id, u_id_two)
# Making token_one an owner
channel_addowner(token, channel_id, u_id_one)
# checking output matches local data base
data = getData()
for channels in data['channels']:
if channels['channel_id'] == channel_id:
assert channels['owner_members'] == [{
"u_id": u_id,
"name_first": "first9name",
"name_last": "last9name"
}, {
"u_id": u_id_one,
"name_first": "first6name1",
"name_last": "last6name1"
}]
# Testing function with recently declared owner (token_one) to check if he has owner permissions
assert channel_addowner(token_one, channel_id, u_id_two) == {}
# checking output matches local data base
data = getData()
for channels in data['channels']:
if channels['channel_id'] == channel_id:
assert channels['owner_members'] == [{
"u_id": u_id,
"name_first": "first9name",
"name_last": "last9name"
}, {
"u_id": u_id_one,
"name_first": "first6name1",
"name_last": "last6name1"
}, {
"u_id": u_id_two,
"name_first": "firstname2",
"name_last": "lastname2"
}]
