def test_channels_create():
reset_data()
# SETUP BEGIN
# Assume all users have registered in function: test_channel_invite()
auth_dic1 = auth_register("*****@*****.**", "123456", "firstone",
"lastone")
auth_dic1 = auth_login("*****@*****.**", "123456")
token1 = auth_dic1['token']
auth_dic2 = auth_register("*****@*****.**", "123456", "firstone",
"lastone")
auth_dic2 = auth_login("*****@*****.**", "123456")
token2 = auth_dic2['token']
# SETUP END
# successful test
# assume the channelid is 1
assert channels_create(token1, "channel 1", True) == {'channel_id': 0}
with pytest.raises(ValueError):
# Name is more than 20 characters long
channels_create(token1, "qwertyuiopasdfghjklzxcvbnmqwertyuiop", True)
# logout
auth_logout(token1)
auth_logout(token2)
reset_data()
def test_message_send():
reset_data()
# SETUP BEGIN
authRegisterDict1 = auth_register('*****@*****.**', '123456', 'hayden',
'Diego')
auth_login('*****@*****.**', '123456')
token1 = authRegisterDict1['token']
authRegisterDict2 = auth_register('*****@*****.**', '123456', 'sally',
'Juan')
auth_login('*****@*****.**', '123456')
token2 = authRegisterDict2['token']
channelidDict1 = channels_create(token1, 'channel_1', True)
channel_id1 = channelidDict1['channel_id']
channelidDict2 = channels_create(token2, 'channel_8', True)
channel_id2 = channelidDict2['channel_id']
# SETUP END
# The right example
message_send(token1, channel_id1, 'hello')
# error test
with pytest.raises(ValueError):
# Message is more than 1000 characters
message_send(token1, channel_id1, 'a' * 1001)
with pytest.raises(AccessError):
# token1 has not joined Channel channel_id2
message_send(token1, channel_id2, 'hello')
# logout
auth_logout(token1)
auth_logout(token2)
reset_data()
def test_channels_listall():
reset_data()
# SETUP BEGIN
# Assume all users have registered in function: test_channel_invite()
auth_dic1 = auth_register("*****@*****.**", "123456", "firstone", "lastone")
auth_dic1 = auth_login("*****@*****.**", "123456")
token1 = auth_dic1['token']
auth_dic2 = auth_register("*****@*****.**", "123456", "firstone", "lastone")
auth_dic2 = auth_login("*****@*****.**", "123456")
token2 = auth_dic2['token']
channels_create(token1, "channel 1", True)
# SETUP END
# successful test
# because it output all channel, whatever the user is, the output should be same
assert channels_listall(token1) == channels_listall(token2) # just for check
# logout
auth_logout(token1)
auth_logout(token2)
reset_data()
def test_channels_list():
reset_data()
# SETUP BEGIN
# Assume all users have registered in function: test_channel_invite()
auth_dic1 = auth_register("*****@*****.**", "123456", "firstone",
"lastone")
auth_dic1 = auth_login("*****@*****.**", "123456")
token1 = auth_dic1['token']
auth_dic2 = auth_register("*****@*****.**", "123456", "firstone",
"lastone")
auth_dic2 = auth_login("*****@*****.**", "123456")
token2 = auth_dic2['token']
channels_create(token1, "channel 1", True)
# SETUP END
# successful test
channels_list(token1)
assert channels_list(token2) == {'channels': []}
# logout
auth_logout(token1)
auth_logout(token2)
reset_data()
def test_channel_invite():
reset_data()
# SETUP BEGIN
auth_dic1 = auth_register("*****@*****.**", "123456", "firstone",
"lastone")
auth_dic1 = auth_login("*****@*****.**", "123456")
token1 = auth_dic1['token']
uid1 = auth_dic1['u_id']
auth_dic2 = auth_register("*****@*****.**", "123456", "firstone",
"lastone")
auth_dic2 = auth_login("*****@*****.**", "123456")
token2 = auth_dic2['token']
uid2 = auth_dic2['u_id']
auth_dic3 = auth_register("*****@*****.**", "123456", "firstone",
"lastone")
auth_dic3 = auth_login("*****@*****.**", "123456")
token3 = auth_dic3['token']
channelid_dic1 = channels_create(token1, "channel 1", True)
channel_id1 = channelid_dic1['channel_id']
channelid_dic2 = channels_create(token1, "channel 2", True)
channel_id2 = channelid_dic2['channel_id']
# SETUP END
# successful test
assert channel_invite(token1, channel_id1, uid2) == {}
# error test
with pytest.raises(ValueError):
# the channel if does not exist
channel_invite(token1, 10, uid2)
with pytest.raises(AccessError):
# channel_id does not refer to a valid channel that the authorised user is part of.
channel_invite(token3, channel_id2, uid2)
with pytest.raises(ValueError):
# u_id does not refer to a valid user
# assume u_id 5 does not refer to a valid user
channel_invite(token1, channel_id1, 10)
with pytest.raises(ValueError):
# u_id does not refer to a valid user
# invite the user that is in channel (by calling function above, uid2 is in channel)
channel_invite(token2, channel_id1, uid1)
# logout
auth_logout(token1)
auth_logout(token2)
auth_logout(token3)
reset_data()
def test_message_sendlater():
reset_data()
# SETUP BEGIN
authRegisterDict1 = auth_register('*****@*****.**', '123456', 'hayden',
'Diego')
auth_login('*****@*****.**', '123456')
token1 = authRegisterDict1['token']
authRegisterDict2 = auth_register('*****@*****.**', '123456', 'sally',
'Juan')
auth_login('*****@*****.**', '123456')
token2 = authRegisterDict2['token']
channelidDict1 = channels_create(token1, 'channel_1', True)
channel_id1 = channelidDict1['channel_id']
channelidDict2 = channels_create(token2, 'channel_8', True)
channel_id2 = channelidDict2['channel_id']
# SETUP END
# The right example
'''
later_time = datetime.datetime.utcnow() + datetime.timedelta(seconds=50)
str_later_time = later_time.strftime("%Y-%m-%d %H:%M:%S")
timeArray = time.strptime(str_later_time, "%Y-%m-%d %H:%M:%S")
timestamp = time.mktime(timeArray)
print(timestamp)
'''
timestamp = int(datetime.datetime.now().strftime("%s")) + 3
mid = message_sendlater(token1, channel_id1, 'hello', timestamp)
assert mid['message_id'] == 1
# error example
with pytest.raises(ValueError):
# Message is more than 1000 characters
message_sendlater(token1, channel_id1, 'a' * 1001, 1603066156)
with pytest.raises(ValueError):
# Assume Channel channel_id 3 does not exist (not valid channel)
message_sendlater(token1, 3, 'hello', 1603066156)
with pytest.raises(ValueError):
# Assume Time 2018-10-01 00:09:06 is a time in the past (1538352546 in Timestamp)
message_sendlater(token1, channel_id1, 'hello', 1538352546)
with pytest.raises(AccessError):
# token1 has not joined Channel channel_id2
message_sendlater(token1, channel_id2, 'hello', 1603066156)
# logout
auth_logout(token1)
auth_logout(token2)
reset_data()
def test_standup_active():
reset_data()
#SETUP Begin
authRegDict1 = auth_register("*****@*****.**", "qwerty", "John", "Smith")
token1 = authRegDict1['token']
channelCreateDict1 = channels_create(token1, 'New Channel', True)
channel_id1 = channelCreateDict1['channel_id']
authRegDict2 = auth_register("*****@*****.**", "asdfgh", "Jim", "Smith")
token2 = authRegDict2['token']
assert standup_active(token1, channel_id1) == {'is_active' : False, 'time_finish' : None}
standup_start(token1, channel_id1, 5)
standup_dic = standup_active(token1, channel_id1)
assert standup_dic['is_active']
with pytest.raises(ValueError):
standup_active(token1, 10)
with pytest.raises(AccessError):
standup_active(token2, channel_id1)
auth_logout(token1)
auth_logout(token2)
def test_message_unpin():
reset_data()
# SETUP BEGIN
authRegisterDict1 = auth_register('*****@*****.**', '123456', 'hayden',
'Diego')
auth_login('*****@*****.**', '123456')
token1 = authRegisterDict1['token']
authRegisterDict2 = auth_register('*****@*****.**', '123456', 'sally',
'Juan')
auth_login('*****@*****.**', '123456')
token2 = authRegisterDict2['token']
authRegisterDict3 = auth_register('*****@*****.**', '123456', 'Nena',
'Smith')
auth_login('*****@*****.**', '123456')
token3 = authRegisterDict3['token']
authRegisterDict4 = auth_register('*****@*****.**', '123456', 'Carmen',
'Davis')
auth_login('*****@*****.**', '123456')
token4 = authRegisterDict4['token']
channelidDict1 = channels_create(token1, 'channel_1', True)
channel_id1 = channelidDict1['channel_id']
channel_join(token2, channel_id1)
messages_dic1 = message_send(token1, channel_id1, "hello")
message_id1 = messages_dic1['message_id']
messagedic2 = message_send(token1, channel_id1, "helloooo")
message_id2 = messagedic2['message_id']
message_pin(token1, message_id1)
message_pin(token1, message_id2)
# SETUP END
# The right example
assert message_unpin(token1, message_id1) == {}
with pytest.raises(ValueError):
# message_id 8 is not a valid message
message_unpin(token1, 8)
with pytest.raises(ValueError):
# The authorised user token2 is not an admin
message_unpin(token2, message_id2)
with pytest.raises(ValueError):
# Message message_1 is already unpinned
message_unpin(token1, message_id1)
with pytest.raises(AccessError):
# The authorised user is not a member of the channel that the message is within
message_unpin(token3, message_id2)
# logout
auth_logout(token1)
auth_logout(token2)
auth_logout(token3)
auth_logout(token4)
reset_data()
def test_search():
'''
assumption:
[email protected] is the only registered email for now.
2.all the value errors have been modified into specfic words.
3.the channel called "channelname" hasn't been created
'''
#successful test:
#login
reset_data()
auth_register('*****@*****.**', 'q1w2e3r4', 'BEAR', 'XI')
login1_dic = auth_login('*****@*****.**', 'q1w2e3r4')
token = login1_dic['token']
#create a channel
channelValue = channels_create(token, "channelname", True)
channel_id = channelValue['channel_id']
#sending a message
message_send(token, channel_id, "1q2w3e4r")
#search
messages_dic = search(token, "1q")
assert messages_dic['messages'][0]['message'] == "1q2w3e4r"
#logout
auth_logout(token)
reset_data()
def test1():
restart()
authRegisterDict1 = auth_register("*****@*****.**", "123456",
"Tim", "Hu")
token1 = authRegisterDict1["token"]
UID1 = authRegisterDict1['u_id']
authRegisterDict2 = auth_register("*****@*****.**", "1we33456",
"Hayden", "Smith")
token2 = authRegisterDict2["token"]
UID2 = authRegisterDict2['u_id']
authRegisterDict3 = auth_register("*****@*****.**", "1we33ee456",
"Jeff", "Lu")
token3 = authRegisterDict3["token"]
UID3 = authRegisterDict3['u_id']
authRegisterDict4 = auth_register("*****@*****.**", "jijijij37236",
'daniel', 'quin')
token4 = authRegisterDict4["token"]
UID4 = authRegisterDict4['u_id']
channel_id = channels_create(token1, 'test1', True)
channel_invite(token1, channel_id, UID2)
channel_invite(token1, channel_id, UID3)
message_send(token1, channel_id, 'hello')
message_send(token2, channel_id, 'hi')
message_send(token3, channel_id, 'numb')
result = search(token1, 'hello')
assert result['messages'][0]['message'] == 'hello'
assert result['messages'][0]['message_id'] == 1
def test_message_edit():
reset_data()
# SETUP BEGIN
authRegisterDict1 = auth_register('*****@*****.**', '123456', 'hayden',
'Diego')
auth_login('*****@*****.**', '123456')
token1 = authRegisterDict1['token']
authRegisterDict2 = auth_register('*****@*****.**', '123456', 'sally',
'Juan')
auth_login('*****@*****.**', '123456')
token2 = authRegisterDict2['token']
authRegisterDict3 = auth_register('*****@*****.**', '123456', 'Nena',
'Smith')
auth_login('*****@*****.**', '123456')
token3 = authRegisterDict3['token']
authRegisterDict4 = auth_register('*****@*****.**', '123456', 'Carmen',
'Davis')
auth_login('*****@*****.**', '123456')
token4 = authRegisterDict4['token']
channelidDict1 = channels_create(token1, 'channel_1', True)
channel_id1 = channelidDict1['channel_id']
channel_join(token2, channel_id1)
messages_dic1 = message_send(token1, channel_id1, "hello")
message_id1 = messages_dic1['message_id']
# SETUP END
# The right example
# Assume the message id 1 is a valid id for user1
assert message_edit(token1, message_id1, 'hello') == {}
with pytest.raises(ValueError):
# Assume Message id 2 does not exist
message_edit(token1, 10, 'hello')
with pytest.raises(ValueError):
# Message is more than 1000 characters
message_edit(token1, message_id1, 'a' * 1001)
with pytest.raises(AccessError):
# message_id1 was not sent by the authorised user token2 making this request
message_edit(token2, message_id1, 'hello')
with pytest.raises(AccessError):
# token3 is not an owner of this channel
message_edit(token3, message_id1, 'hello')
with pytest.raises(AccessError):
# token4 is not an admin or owner of the slack
message_edit(token4, message_id1, 'hello')
# logout
auth_logout(token1)
auth_logout(token2)
auth_logout(token3)
auth_logout(token4)
reset_data()
def test_channel_join():
reset_data()
# SETUP BEGIN
# Assume all users have registered in function: test_channel_invite()
auth_dic1 = auth_register("*****@*****.**", "123456", "firstone",
"lastone")
auth_dic1 = auth_login("*****@*****.**", "123456")
token1 = auth_dic1['token']
auth_dic2 = auth_register("*****@*****.**", "123456", "firstone",
"lastone")
auth_dic2 = auth_login("*****@*****.**", "123456")
token2 = auth_dic2['token']
channelid_dic1 = channels_create(token1, "channel 1", True)
channel_id1 = channelid_dic1['channel_id']
# create a private channel
channelid_dic2 = channels_create(token1, "channel 2", False)
channel_id2 = channelid_dic2['channel_id']
# SETUP END
# successful test
assert channel_join(token2, channel_id1) == {}
# error test
with pytest.raises(ValueError):
# Channel (based on ID) does not exist
# assume channel id 3 does not exist
channel_join(token1, 10)
with pytest.raises(ValueError):
# if token is already a member in this channel
channel_join(token2, channel_id1)
with pytest.raises(AccessError):
# channel_id refers to a channel that is private (when the authorised user is not an admin)
channel_join(token2, channel_id2)
# logout
auth_logout(token1)
auth_logout(token2)
reset_data()
def test_active():
restart()
authRegisterDict1 = auth_register("*****@*****.**","123456","Tim","Hu")
token1 = authRegisterDict1["token"]
channel_id = channels_create(token1,'test1',True)
standup_start(token1,channel_id, 20)
standup_active(token1, 1)
with pytest.raises(ValueError, match=r'.*'):
standup_active(token1, -5)
def test_standup_send():
reset_data()
#SETUP Begin
authRegDict1 = auth_register("*****@*****.**", "qwerty", "John", "Smith")
token1 = authRegDict1['token']
channelCreateDict1 = channels_create(token1, 'New Channel', True)
channel_id1 = channelCreateDict1['channel_id']
authRegDict2 = auth_register("*****@*****.**", "asdfgh", "Jim", "Smith")
token2 = authRegDict2['token']
channelCreateDict2 = channels_create(token2, 'New Channel2', True)
channel_id2 = channelCreateDict2['channel_id']
standup_start(token1, channel_id1, 7)
#User 2 has not joined the 'New Channel' created by user 1
#SETUP End
#Test Case 1: Successful message sent to get bufferred in the standup queue
assert standup_send(token1, channel_id1, 'Hello') == {}
#Test Case 2: Unsuccessful message due to channel not existing
with pytest.raises(ValueError):
standup_send(
token1, 10,
'Hello') #Invalid channel ID hence the unsuccessful message
#Test Case 3: Unsuccessful message due to message being more than 1000 characters
with pytest.raises(ValueError):
standup_send(token1, channel_id1, 'a' * 1001)
#Test Case 4: Unsuccessful message due to user not being a member of the channel
with pytest.raises(AccessError):
#user 2 has not joined the channel created by user 1 so the message is Unsuccessful
standup_send(token2, channel_id1, 'Hello')
#Test Case 5: Unsuccessful standup message due to standup not being active
with pytest.raises(ValueError):
standup_send(token2, channel_id2, 'Hello')
auth_logout(token1)
auth_logout(token2)
reset_data()
def test_standup_all():
restart()
authRegisterDict1 = auth_register("*****@*****.**","123456","Tim","Hu")
token1 = authRegisterDict1["token"]
authRegisterDict2 = auth_register("*****@*****.**","1we33456","Hayden","Smith")
token2 = authRegisterDict2["token"]
UID2 = authRegisterDict2['u_id']
authRegisterDict3 = auth_register(
"*****@*****.**", "1we33ee456", "Jeff", "Lu")
token3 = authRegisterDict3["token"]
UID3 = authRegisterDict3['u_id']
authRegisterDict4 = auth_register(
"*****@*****.**", "jijijij37236", 'daniel', 'quin')
token4 = authRegisterDict4["token"]
channel_id = channels_create(token1,'test1',True)
channel_invite(token1,channel_id,UID2)
channel_invite(token1,channel_id,UID3)
showtime(20)
with pytest.raises(ValueError, match=r".*"):
standup_send(token2, channel_id, 'hello')
standup_start(token1,channel_id, 20)
with pytest.raises(ValueError, match = r".*"):
standup_start(token2, channel_id, 20)
with pytest.raises(AccessError, match=r".*"):
standup_start(token4,channel_id, 20)
with pytest.raises(ValueError,match = r".*"):
standup_start(token1,-1, 20)
with pytest.raises(AccessError, match=r".*"):
standup_send(token4, channel_id , 'hello')
with pytest.raises(ValueError, match=r".*"):
standup_send(token1, -1 , 'hello')
with pytest.raises(ValueError, match=r".*"):
standup_send(token3, channel_id, "dhbfuyawgefdahdhbfuyawgefdahsgfhiashfuihasfnrweiauehcyaacweynugirnnnnnnnnnnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnfnnnnnnnnnnnnnnnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfaecntyvufyyyyyyyyyyyyyyyfyfyfygyyywyyyyyyyyyyyyyyywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywydhbfuyawgefdahsgfhiashfuihasfnrweiauehcyaacweynugirnnnnnnnnnnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnfnnnnnnnnnnnnnnnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfaecntyvufyyyyyyyyyyyyyyyfyfyfygyyywyyyyyyyyyyyyyyywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywydhbfuyawgefdahsgfhiashfuihasfnrweiauehcyaacweynugirnnnnnnnnnnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnfnnnnnnnnnnnnnnnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfaecntyvufyyyyyyyyyyyyyyyfyfyfygyyywyyyyyyyyyyyyyyywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywyywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywyywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywyysgfhiashfuihasfnrweiauehcyaacweynugirnnnnnnnnnnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnrnfnnnnnnnnnnnnnnnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfnfaecntyvufyyyyyyyyyyyyyyyfyfyfygyyywyyyyyyyyyyyyyyywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywywyy")
standup_send(token2,channel_id, 'hello')
standup_send(token3,channel_id,'daniel')
standup_send(token2,channel_id, 'quin' )
channelDict = load()['channelDict']
for ch in channelDict:
if int(channel_id) == ch['channel_id']:
assert 'hayden: hello' + '\r\n' + 'jeff: daniel' + '\r\n' + 'hayden: quin' == ch['standlist']
pass
def run_channels_create():
"""
Run the channels_create function to make a new channel and
add it to the server database
"""
request_data = request.form
return_value = channel.channels_create(request_data["token"],
request_data["name"],
request_data["is_public"] == 'true')
return dumps(return_value)
def test_message_react():
reset_data()
# SETUP BEGIN
authRegisterDict1 = auth_register('*****@*****.**', '123456', 'hayden', 'Diego')
auth_login('*****@*****.**', '123456')
token1 = authRegisterDict1['token']
authRegisterDict2 = auth_register('*****@*****.**', '123456', 'sally', 'Juan')
auth_login('*****@*****.**', '123456')
token2 = authRegisterDict2['token']
authRegisterDict3 = auth_register('*****@*****.**', '123456', 'Nena', 'Smith')
auth_login('*****@*****.**', '123456')
token3 = authRegisterDict3['token']
authRegisterDict4 = auth_register('*****@*****.**', '123456', 'Carmen', 'Davis')
auth_login('*****@*****.**', '123456')
token4 = authRegisterDict4['token']
channelidDict1 = channels_create(token1, 'channel_1', True)
channel_id1 = channelidDict1['channel_id']
channel_join(token2, channel_id1)
messages_dic1 = message_send(token1, channel_id1, "hello")
message_id1 = messages_dic1['message_id']
# SETUP END
# The right example
# message_id1 is a valid message for user1
# assume the react id 1 is a valid id
assert message_react(token1, message_id1, 1) == {}
# error example
with pytest.raises(ValueError):
# assume message_id 2 is not a valid message
message_react(token1, 2, 1)
with pytest.raises(ValueError):
# assume react_id id 3 is not a valid React ID
message_react(token1, message_id1, 3)
with pytest.raises(ValueError):
# message_id 1 already contains an active React with react_id 1
message_react(token1, message_id1, 1)
with pytest.raises(ValueError):
# user3 is not a member of channel which contain messageid1
message_react(token3, message_id1, 1)
# logout
auth_logout(token1)
auth_logout(token2)
auth_logout(token3)
auth_logout(token4)
def test_channel_messages():
reset_data()
# SETUP BEGIN
# Assume all users have registered in function: test_channel_invite()
auth_dic1 = auth_register("*****@*****.**", "123456", "firstone",
"lastone")
auth_dic1 = auth_login("*****@*****.**", "123456")
token1 = auth_dic1['token']
auth_dic2 = auth_register("*****@*****.**", "123456", "firstone",
"lastone")
auth_dic2 = auth_login("*****@*****.**", "123456")
token2 = auth_dic2['token']
channelid_dic1 = channels_create(token1, "channel 1", True)
channel_id1 = channelid_dic1['channel_id']
# SETUP END
# successful test
# assume the total number of messages in the channel is 0
# which means there is no message in the channel
# assume the start number is 0
# send a message to channel1
message_send(token1, channel_id1, "hello")
channel_messages(token1, channel_id1, 0)
# error test
with pytest.raises(ValueError):
# Channel (based on ID) does not exist
# assume the channel ID 2 does not exist
channel_messages(token1, 10, 0)
with pytest.raises(ValueError):
# start is greater than the total number of messages in the channel
# the total number of messages is 1, start is 2
channel_messages(token1, channel_id1, 2)
with pytest.raises(AccessError):
# Authorised user is not a member of channel with channel_id
channel_messages(token2, channel_id1, 0)
# logout
auth_logout(token1)
auth_logout(token2)
reset_data()
def test_channel_leave():
reset_data()
# SETUP BEGIN
# Assume all users have registered in function: test_channel_invite()
auth_dic1 = auth_register("*****@*****.**", "123456", "firstone",
"lastone")
auth_dic1 = auth_login("*****@*****.**", "123456")
token1 = auth_dic1['token']
auth_dic2 = auth_register("*****@*****.**", "123456", "firstone",
"lastone")
auth_dic2 = auth_login("*****@*****.**", "123456")
token2 = auth_dic2['token']
channelid_dic1 = channels_create(token1, "channel 1", True)
channel_id1 = channelid_dic1['channel_id']
channel_join(token2, channel_id1)
# SETUP END
# successful test
assert channel_leave(token2, channel_id1) == {}
# error test
with pytest.raises(AccessError):
# if the user is not a member of channel with channel id
channel_leave(token2, channel_id1)
# assume if no one in the channel, the channel will does not exist
with pytest.raises(ValueError):
# Channel (based on ID) does not exist
channel_leave(token1, 10)
# if there is only one owner in the channel, cannot remove
with pytest.raises(ValueError):
channel_leave(token1, channel_id1)
# logout
auth_logout(token1)
auth_logout(token2)
reset_data()
def test_channel_details():
reset_data()
# SETUP BEGIN
# Assume all users have registered in function: test_channel_invite()
auth_dic1 = auth_register("*****@*****.**", "123456", "firstone", "lastone")
auth_dic1 = auth_login("*****@*****.**", "123456")
token1 = auth_dic1['token']
auth_dic2 = auth_register("*****@*****.**", "123456", "firstone", "lastone")
auth_dic2 = auth_login("*****@*****.**", "123456")
token2 = auth_dic2['token']
channelid_dic1 = channels_create(token1, "channel 1", True)
channel_id1 = channelid_dic1['channel_id']
# SETUP END
# successful test
# assume channel_details function return the channel name
# and the uid of the owner_members/members
channel_dic = channel_details(token1, channel_id1)
assert channel_dic['name'] == "channel 1"
# error test
with pytest.raises(ValueError):
# Channel (based on ID) does not exist
# assume channel ID 2 does not exist
channel_details(token1, 10)
'''
with pytest.raises(AccessError):
# Authorised user is not a member of channel with channel_id
# user2 is not a member of channel1
channel_details(token2, channel_id1)
'''
# logout
auth_logout(token1)
auth_logout(token2)
reset_data()
def test_standup_start():
reset_data()
#SETUP Begin
authRegDict1 = auth_register("*****@*****.**", "qwerty", "John", "Smith")
token1 = authRegDict1['token']
channelCreateDict1 = channels_create(token1, 'New Channel', True)
channel_id1 = channelCreateDict1['channel_id']
authRegDict2 = auth_register("*****@*****.**", "asdfgh", "Jim", "Smith")
token2 = authRegDict2['token']
#User 2 has not joined the 'New Channel' created by user 1
#SETUP End
#Test Case 1: Successful test case
timestamp = int(datetime.datetime.now().strftime("%s")) + 5
finish = standup_start(token1, channel_id1, 5)['time_finish']
assert finish == timestamp
# Successful test case should return datetime of current time + 5 minutes
#Test Case 2: Unsuccessful test case where channel does not exist
with pytest.raises(ValueError):
standup_start(
token1, 10,
5) #channel ID is invalid hence the unsuccessful function call
#Test Case 3: Unsuccessful start of standup
# due to user not being a member of the channel he/she is trying to send the message in
with pytest.raises(AccessError):
standup_start(token2, channel_id1, 5)
#Test Case 3: Unsuccessful start of standup
# because An active standup is currently running in this channel
with pytest.raises(ValueError):
standup_start(token1, channel_id1, 5)
auth_logout(token1)
auth_logout(token2)
reset_data()
def app_channels_create():
token = get_args('token')
name = get_args('name')
is_public = str2bool(get_args('is_public'))
return dumps(channels_create(token, name, is_public))
def test_message_remove():
reset_data()
# SETUP BEGIN
authRegisterDict1 = auth_register('*****@*****.**', '123456', 'hayden', 'Diego')
auth_login('*****@*****.**', '123456')
token1 = authRegisterDict1['token']
authRegisterDict2 = auth_register('*****@*****.**', '123456', 'sally', 'Juan')
auth_login('*****@*****.**', '123456')
token2 = authRegisterDict2['token']
uid2 = authRegisterDict2['u_id']
authRegisterDict3 = auth_register('*****@*****.**', '123456', 'Nena', 'Smith')
auth_login('*****@*****.**', '123456')
token3 = authRegisterDict3['token']
authRegisterDict4 = auth_register('*****@*****.**', '123456', 'Carmen', 'Davis')
auth_login('*****@*****.**', '123456')
token4 = authRegisterDict4['token']
channelidDict1 = channels_create(token1, 'channel_1', True)
channel_id1 = channelidDict1['channel_id']
channel_join(token2, channel_id1)
channel_addowner(token1, channel_id1, uid2)
channel_join(token3, channel_id1)
messages_dic1 = message_send(token1, channel_id1, "hello")
message_id = messages_dic1['message_id']
# SETUP END
# The right example
# the message_id is a valid message for user1
assert message_remove(token1, message_id) == {}
# send again
messages_dic1 = message_send(token1, channel_id1, "hello")
message_id = messages_dic1['message_id']
# the right example
# Message_id was not sent by the authorised user token2,
# but the token2 is a owner of this channel
assert message_remove(token2, message_id) == {}
# send again
messages_dic1 = message_send(token1, channel_id1, "hello")
message_id = messages_dic1['message_id']
with pytest.raises(ValueError):
# assume Message id 2 no longer exists
message_remove(token1, 10)
with pytest.raises(AccessError):
# assume token3 is not an owner of this channel that contain message_id
message_remove(token3, message_id)
with pytest.raises(AccessError):
# assume token4 is not an admin or owner of the slack
message_remove(token4, message_id)
# logout
auth_logout(token1)
auth_logout(token2)
auth_logout(token3)
auth_logout(token4)
def channel_create():
token = request.form.get("token")
name = request.form.get("name")
is_public = request.form.get("is_public")
return dumps(channels_create(token, name, is_public))
def test_channel_addowner():
reset_data()
# SETUP BEGIN
# Assume all users have registered in function: test_channel_invite()
auth_dic1 = auth_register("*****@*****.**", "123456", "firstone",
"lastone")
auth_login("*****@*****.**", "123456")
token1 = auth_dic1['token']
auth_dic2 = auth_register("*****@*****.**", "123456", "firstone",
"lastone")
auth_dic2 = auth_login("*****@*****.**", "123456")
token2 = auth_dic2['token']
uid2 = auth_dic2['u_id']
auth_dic3 = auth_register("*****@*****.**", "123456", "firstone",
"lastone")
auth_dic3 = auth_login("*****@*****.**", "123456")
token3 = auth_dic3['token']
uid3 = auth_dic3['u_id']
channelid_dic1 = channels_create(token1, "channel 1", True)
channel_id1 = channelid_dic1['channel_id']
channel_join(token2, channel_id1)
channel_join(token3, channel_id1)
# create a private channel
channelid_dic2 = channels_create(token2, "channel 2", True)
channel_id2 = channelid_dic2['channel_id']
channel_join(token3, channel_id2)
# SETUP END
# successful test
assert channel_addowner(token1, channel_id1, uid2) == {}
assert channel_addowner(token1, channel_id2,
uid3) == {} # token 1 is the owner of the slackr
# error test
with pytest.raises(ValueError):
# Channel (based on ID) does not exist
channel_addowner(token1, 10, uid2)
with pytest.raises(ValueError):
# When user with user id u_id is already an owner of the channel
channel_addowner(token1, channel_id1, uid2)
with pytest.raises(ValueError):
# When the user with u_id is not a member of the channel
channel_addowner(token1, channel_id2, uid2)
with pytest.raises(AccessError):
# when the authorised user is not an owner of the slackr, or an owner of this channel
channel_addowner(token3, channel_id1, uid3)
# logout
auth_logout(token1)
auth_logout(token2)
auth_logout(token3)
reset_data()
