def test_invalid_channel_create():
'''
Testing error cases of channel_create
'''
# Invalid token
with pytest.raises(AccessError):
channel_create('invalidToken', 'test', "true")
def test_channel_join():
'''
The following tests channel_join add's a user to channel
'''
reset_data()
# START SETUP
token = auth_register('*****@*****.**', 'pass123', 'john',
'apple')['token']
channel_id_public = channel_create(token, 'newChannel', 'true')
channel_id_private = channel_create(token, 'privateChannel', 'false')
# END SETUP
# Invalid channel ID
with pytest.raises(ValueError):
channel_join(token, 666)
# Invalid token
with pytest.raises(AccessError):
channel_join('invalidToken', channel_id_public)
# Trys to join private channel
with pytest.raises(AccessError):
channel_join(token, channel_id_private)
# Working channel_join
channel_join(token, channel_id_public)
def test_simple():
'''
Test sending multiple messages in different channels
'''
reset_data()
# SETUP
registered_user = auth_register('*****@*****.**', '123456', 'John',
'Smith')
token = registered_user['token']
c_id = channel_create(token, 'Channel1', 'true')
# SETUP END
# Send message
message_send(token, c_id, 'Hello world!')
message_list = get_messages(c_id)
assert find_message(message_list, 'Hello world!') == 'Hello world!'
# Send message to a channel that already has a message
message_send(token, c_id, 'another message')
message_list = get_messages(c_id)
assert find_message(message_list, 'Hello world!') == 'Hello world!'
assert find_message(message_list, 'another message') == 'another message'
# Send message to another channel
c2_id = channel_create(token, 'Channel2', 'true')
# Send message
message_send(token, c2_id, 'Hello world!')
message_list = get_messages(c2_id)
assert find_message(message_list, 'Hello world!') == 'Hello world!'
def test_channel_details():
'''
Testing cases of channel_details
'''
reset_data()
# START SETUP
token = auth_register('*****@*****.**', 'pass123', 'john',
'apple')['token']
second_token = auth_register('*****@*****.**', 'pass147', 'vicks',
'uwu')['token']
channel_id_private = channel_create(token, 'privateChannel', 'false')
third_token = auth_register('*****@*****.**', 'pass134124', 'lol',
'lmao')['token']
channel_id_public = channel_create(token, 'newChannel', 'true')
channel_id_private = channel_create(token, 'privateChannel', 'false')
# END SETUP
# Invalid token
with pytest.raises(AccessError):
channel_details('invalidToken', channel_id_public)
# User is not part of target channel
with pytest.raises(AccessError):
channel_details(third_token, channel_id_private)
# Working channel details
channel_join(second_token, channel_id_public)
channel_details(token, channel_id_public)
channel_details(second_token, channel_id_public)
def test_simple_sendlater():
'''
Test sendlater with multiple messages in different channels
'''
reset_data()
# SETUP
registered_user = auth_register('*****@*****.**', '123456', 'John',
'Smith')
token = registered_user['token']
c_id = channel_create(token, 'Channel1', 'true')
# SETUP END
# Send message later
time_sent = int(t.time() + 10)
msg_id = message_sendlater(token, c_id, 'Hello world', time_sent)
# Assert is stored for later
assert check_later(msg_id) is msg_id
# Sending message later in another channel
c2_id = channel_create(token, 'Channel1', 'true')
# Send message later
time_sent = t.time() + 10
msg_id3 = message_sendlater(token, c2_id, 'Hello world', time_sent)
# Assert message is in channel
assert check_later(msg_id3) is msg_id3
def test_invalid_name():
'''
Testing if the name given for channel_create is invalid
'''
# set up begins
token = auth_register('*****@*****.**', 'pass123', 'john',
'apple')['token']
# set up ends
with pytest.raises(ValueError, match=r"*"):
channel_create(token, 'WaitWaitWaitWaitWaitW', True)
reset_data()
def test_is_public_valid_for_channel_create():
'''
Testing if the the input of is_public is valid
'''
# set up begins
token = auth_register('*****@*****.**', 'pass123', 'john',
'apple')['token']
# set up ends
# invalid input for is_public
with pytest.raises(ValueError):
channel_create(token, 'Shawn', 'yes')
reset_data()
def test_channel_addowner():
'''
The following test's various cases of channel_addowner
'''
reset_data()
# START SETUP
token = auth_register('*****@*****.**', 'pass123', 'john',
'apple')['token']
creator_id = token_to_user(token)
channel_id_public = channel_create(token, 'newChannel', 'true')
second_token = auth_register('*****@*****.**', 'pass147', 'vicks',
'uwu')['token']
second_user_id = token_to_user(second_token)
third_token = auth_register('*****@*****.**', 'pass134124', 'lol',
'lmao')['token']
third_user_id = token_to_user(third_token)
# END SETUP
# Invalid token
with pytest.raises(AccessError):
channel_addowner('invalidToken', channel_id_public, second_user_id)
# Invalid channel ID
with pytest.raises(ValueError):
channel_addowner(token, 666, second_user_id)
# trying to add when user is not in the channel
with pytest.raises(ValueError):
channel_addowner(second_token, channel_id_public, third_user_id)
# trying to add random channel
with pytest.raises(ValueError):
channel_addowner(second_token, 999, third_user_id)
# User is already an owner
second_channel_id = channel_create(third_token, 'anotherCHannel', 'true')
with pytest.raises(ValueError):
channel_addowner(token, second_channel_id, third_user_id)
# When user is not an admin or owner
channel_join(second_token, channel_id_public)
channel_join(third_token, channel_id_public)
with pytest.raises(AccessError):
channel_addowner(second_token, channel_id_public, third_user_id)
# Attempting to change permission of Slackr creator
with pytest.raises(AccessError):
channel_addowner(second_token, channel_id_public, creator_id)
# Working addowner
channel_addowner(token, channel_id_public, third_user_id)
def test_standupsend():
'''
Test standup_send in an active standup
'''
reset_data()
# SETUP
registered_user = auth_register('*****@*****.**', '123456', 'John',
'Smith')
token = registered_user['token']
c_id = channel_create(token, 'Channel1', 'true')
# SETUP END
standup_start(token, c_id, 60)
message = "hello world"
standup_send(token, c_id, message)
message_list = standup_messages(c_id)
assert find_standup_msg(message_list, message) is message
# Send another message
message2 = "another message"
standup_send(token, c_id, message2)
message_list = standup_messages(c_id)
assert find_standup_msg(message_list, message2) is message2
def test_message_unreact():
'''
Test working message_unreact and its errors
'''
reset_data()
# SETUP START
token = auth_register('*****@*****.**', 'pass123', 'john',
'apple')['token']
second_token = auth_register('*****@*****.**', 'pass147', 'vicks',
'uwu')['token']
channel_id_public = channel_create(token, 'newChannel', 'true')
msg_id = message_send(token, channel_id_public, "firstMessage")
react_id = 1
message_react(token, msg_id, react_id)
# SETUP END
# Invalid token
with pytest.raises(AccessError):
message_unreact('invalidToken', msg_id, react_id)
# msg_id is invalid
with pytest.raises(ValueError):
message_unreact(token, 666, react_id)
# User is not in the channel
with pytest.raises(AccessError):
message_unreact(second_token, msg_id, react_id)
# React id is invalid
with pytest.raises(ValueError):
message_unreact(token, msg_id, 200)
# Working unreact
message_unreact(token, msg_id, react_id)
def test_message_edit():
'''
Test edit as the poster of the message on multiple messages
'''
reset_data()
# SETUP
registered_user = auth_register('*****@*****.**', '123456', 'John',
'Smith')
token = registered_user['token']
c_id = channel_create(token, "Channel1", 'true')
# SETUP END
# Add two messages
message_send(token, c_id, "Hello world!")
message_send(token, c_id, "another message")
message_list = get_messages(c_id)
assert find_message(message_list, "Hello world!") == "Hello world!"
assert find_message(message_list, "another message") == "another message"
msg1_id = get_message_id(message_list, "Hello world!")
msg2_id = get_message_id(message_list, "another message")
# SETUP END
message_edit(token, msg1_id, "Updated message")
message_list = get_messages(c_id)
assert find_message(message_list, "Updated message") == "Updated message"
message_edit(token, msg2_id, "Another update")
message_list = get_messages(c_id)
assert find_message(message_list, "Another update") == "Another update"
def test_remove_simple():
'''
Test remove with multiple messages
'''
reset_data()
# SETUP
registered_user = auth_register("*****@*****.**", "123456", "John",
"Smith")
token = registered_user['token']
c_id = channel_create(token, "Channel1", 'true')
# Add two messages
message_send(token, c_id, "Hello world!")
message_send(token, c_id, "another message")
message_list = get_messages(c_id)
assert find_message(message_list, "Hello world!") == "Hello world!"
assert find_message(message_list, "another message") == "another message"
msg1_id = get_message_id(message_list, "Hello world!")
msg2_id = get_message_id(message_list, "another message")
# SETUP END
# Delete both messages one by one
message_remove(token, msg1_id)
message_list = get_messages(c_id)
assert find_message(message_list, "Hello world!") is None
message_remove(token, msg2_id)
message_list = get_messages(c_id)
assert find_message(message_list, "another message") is None
def test_edit_diffuser():
'''
Test edit as a different user
'''
reset_data()
# SETUP
registered_user = auth_register('*****@*****.**', '123456', 'John',
'Smith')
token = registered_user['token']
c_id = channel_create(token, "Channel1", 'true')
# SETUP END
# Add two messages
message_send(token, c_id, "Hello world!")
message_send(token, c_id, "another message")
message_list = get_messages(c_id)
assert find_message(message_list, "Hello world!") == "Hello world!"
assert find_message(message_list, "another message") == "another message"
msg1_id = get_message_id(message_list, "Hello world!")
# Logout
auth_logout(token)
# SETUP
registered_user = auth_register('*****@*****.**', '123456', 'John',
'Smith')
token = registered_user['token']
# SETUP END
with pytest.raises(AccessError, match=r"*"):
message_edit(token, msg1_id, "update")
def test_greaterThanFiftyMessages():
# setup begins
reset_data()
registerNewAccount = auth_register("*****@*****.**", "validpassword", "Night", "s")
u_id = registerNewAccount['u_id']
token = registerNewAccount['token']
newChannel = channel_create(token, "New Channel", True)
channel_id = newChannel
message_send51(token,channel_id,"Hello") # I did not want to write this out 51 times,
# and was unsure how to shorten this
# set up ends
# unable to implement x50 of message send and test during the current iteration
assert channel_messages(token, 123456, 0) == [{"messages": ["Hello"],
"start" : 0, "end" : 0}]
message_send(token,channel_id,"Hello")
assert channel_messages(token, 123456, 0) == [{"messages": ["Hello","Hello"], "start" : 0, "end" : -1}]
def test_remove_owner():
'''
Test remove as an owner of the channel
'''
reset_data()
# SETUP
registered_user = auth_register("*****@*****.**", "123456", "John",
"Smith")
first_token = registered_user['token']
c_id = channel_create(first_token, "Channel1", 'true')
# Add two messages
message_send(first_token, c_id, "Hello world!")
message_list = get_messages(c_id)
# Login as a new user
registered_user = auth_register("*****@*****.**", "1password", "Bob",
"Smith")
token = registered_user['token']
u_id = registered_user['u_id']
# Set new user as a channel owner
channel_join(token, c_id)
channel_addowner(first_token, c_id, u_id)
# SETUP END
msg1_id = get_message_id(message_list, "Hello world!")
message_remove(token, msg1_id)
message_list = get_messages(c_id)
assert find_message(message_list, "Hello world!") is None
def test_remove_admin():
'''
Test remove as an admin of the slack
'''
reset_data()
# SETUP
registered_user = auth_register("*****@*****.**", "123456", "John",
"Smith")
first_token = registered_user['token']
c_id = channel_create(first_token, "Channel1", 'true')
# Add two messages
message_send(first_token, c_id, "Hello world!")
message_send(first_token, c_id, "another message")
message_list = get_messages(c_id)
assert find_message(message_list, "Hello world!") == "Hello world!"
assert find_message(message_list, "another message") == "another message"
# Login as a new user
registered_user = auth_register("*****@*****.**", "1password", "Bob",
"Smith")
token = registered_user['token']
u_id = registered_user['u_id']
# Set new user as an admin of slack
admin_userpermission_change(first_token, u_id, 2)
# SETUP END
message_list = get_messages(c_id)
msg1_id = get_message_id(message_list, "Hello world!")
message_remove(token, msg1_id)
assert find_message(message_list, "Hello world!") is None
def test_remove_diffuser():
'''
Test remove as a different user in the channel
'''
reset_data()
# SETUP
registered_user = auth_register("*****@*****.**", "123456", "John",
"Smith")
token = registered_user['token']
c_id = channel_create(token, "Channel1", 'true')
# Add two messages
message_send(token, c_id, "Hello world!")
message_send(token, c_id, "another message")
message_list = get_messages(c_id)
assert find_message(message_list, "Hello world!") == "Hello world!"
assert find_message(message_list, "another message") == "another message"
msg1_id = get_message_id(message_list, "Hello world!")
# Logout
auth_logout(token)
# Login as a new user
registered_user = auth_register("*****@*****.**", "1password", "Bob",
"Smith")
token = registered_user['token']
# SETUP END
with pytest.raises(AccessError, match=r"*"):
message_remove(token, msg1_id)
def test_edit_notoken():
'''
Test edit with an invalid or no token
'''
reset_data()
# SETUP
registered_user = auth_register('*****@*****.**', '123456', 'John',
'Smith')
token = registered_user['token']
c_id = channel_create(token, "Channel1", 'true')
# SETUP END
# Add two messages
message_send(token, c_id, "Hello world!")
message_send(token, c_id, "another message")
message_list = get_messages(c_id)
assert find_message(message_list, "Hello world!") == "Hello world!"
assert find_message(message_list, "another message") == "another message"
msg1_id = get_message_id(message_list, "Hello world!")
msg2_id = get_message_id(message_list, "another message")
# SETUP END
with pytest.raises(AccessError, match=r"*"):
message_edit("123", msg1_id, "update")
message_edit('', msg2_id, "there is no message")
def test_channel_messages():
'''
Testing cases of channel_messages
'''
reset_data()
# START SETUP
token = auth_register('*****@*****.**', 'pass123', 'john',
'apple')['token']
second_token = auth_register('*****@*****.**', 'pass147', 'vicks',
'uwu')['token']
third_token = auth_register('*****@*****.**', 'pass134124', 'lol',
'lmao')['token']
channel_id_public = channel_create(token, 'newChannel', 'true')
channel_id_private = channel_create(token, 'privateChannel', 'false')
# END SETUP
# Calling Channel messages when there are no messages
with pytest.raises(ValueError):
channel_messages(token, channel_id_public, 0)
# Functioning channel messages base case
message_send(token, channel_id_public, "Hello")
channel_messages(token, channel_id_public, 0)
# Calling Channel messages when current user is not in the target channel
# and target channel is private
message_send(token, channel_id_private, "Hi")
with pytest.raises(AccessError):
channel_messages(second_token, channel_id_private, 0)
# Sending 123 messages and reacting
message_react(token, 0, 1)
channel_join(second_token, channel_id_public)
message_react(second_token, 0, 1)
channel_join(third_token, channel_id_public)
message_send(third_token, channel_id_public, "Hey")
counter = 2
while counter < 124:
message_send(token, channel_id_public, "Hello")
counter = counter + 1
# Testing case where end = -1
channel_messages(token, channel_id_public, 0)
channel_messages(token, channel_id_public, 50)
channel_messages(token, channel_id_public, 100)
def test_channel_removeowner():
'''
Testing cases of channel_removeowner
'''
reset_data()
# START SETUP
token = auth_register('*****@*****.**', 'pass123', 'john',
'apple')['token']
creator_id = token_to_user(token)
channel_id_public = channel_create(token, 'newChannel', 'true')
second_token = auth_register('*****@*****.**', 'pass147', 'vicks',
'uwu')['token']
second_user_id = token_to_user(second_token)
third_token = auth_register('*****@*****.**', 'pass134124', 'lol',
'lmao')['token']
third_user_id = token_to_user(third_token)
fourth_token = auth_register('*****@*****.**', 'pass13424', 'Troye',
'Bob')['token']
fourth_user_id = token_to_user(fourth_token)
# END SETUP
# Trying to remove someone not in the channel
with pytest.raises(ValueError):
channel_removeowner(token, channel_id_public, fourth_user_id)
# Invalid token
with pytest.raises(AccessError):
channel_removeowner('invalidToken', channel_id_public, second_user_id)
# Invalid channel ID
with pytest.raises(ValueError):
channel_removeowner(token, 666, third_user_id)
# User already not an owner
channel_join(fourth_token, channel_id_public)
with pytest.raises(ValueError):
channel_removeowner(token, channel_id_public, fourth_user_id)
# User is not an admin or owner
channel_join(second_token, channel_id_public)
channel_join(third_token, channel_id_public)
channel_addowner(token, channel_id_public, second_user_id)
with pytest.raises(AccessError):
channel_removeowner(third_token, channel_id_public, second_user_id)
# Attempting to change permission of Slackr creator
with pytest.raises(AccessError):
channel_removeowner(second_token, channel_id_public, creator_id)
# Working removeowner
channel_join(third_token, channel_id_public)
channel_addowner(token, channel_id_public, third_user_id)
channel_removeowner(token, channel_id_public, third_user_id)
def test_channel_invite():
'''
Testing cases of channel_invite
'''
reset_data()
# START SETUP
token = auth_register('*****@*****.**', 'pass123', 'john',
'apple')['token']
second_token = auth_register('*****@*****.**', 'pass147', 'vicks',
'uwu')['token']
second_user_id = token_to_user(second_token)
channel_id_private = channel_create(token, 'privateChannel', 'false')
channel_id_public = channel_create(token, 'NotPrivate', 'true')
third_token = auth_register('*****@*****.**', 'pass134124', 'lol',
'lmao')['token']
third_user_id = token_to_user(third_token)
# END SETUP
# check if the current user who is inviting is actually part of the target channel
with pytest.raises(AccessError):
channel_invite(second_token, channel_id_private, third_user_id)
# Invalid token
with pytest.raises(AccessError):
channel_invite('invalidToken', channel_id_private, second_user_id)
# Working channel invite
channel_invite(token, channel_id_private, third_user_id)
assert check_channel_member(third_user_id, channel_id_private)
# Inviting user who is already in the channel
with pytest.raises(AccessError):
channel_invite(second_token, channel_id_public, third_user_id)
# Target user already in channel
with pytest.raises(ValueError):
channel_invite(token, channel_id_private, third_user_id)
def test_lessThanFiftyMessages():
# setup begins
reset_data()
registerNewAccount = auth_register("*****@*****.**", "validpassword", "Night", "s")
u_id = registerNewAccount['u_id']
token = registerNewAccount['token']
newChannel = channel_create(token, "New Channel", True)
channel_id = newChannel
message_send(token,channel_id,"Hello")
# set up ends
assert channel_messages(token, 123456, 0) == [{"messages": "Hello", "start" : 0, "end" : -1}]
def test_long():
'''
Test sending a message over maxmium character limit (1000)
'''
reset_data()
# SETUP
registered_user = auth_register('*****@*****.**', '123456', 'John',
'Smith')
token = registered_user['token']
c_id = channel_create(token, 'Channel1', 'true')
# SETUP END
with pytest.raises(ValueError, match=r"*Over 1000 characters*"):
message_send(token, c_id, 'long message' * 1000)
message_send(token, c_id, 'very' * 1001)
def test_no_message():
'''
Test sending a message with no input
'''
reset_data()
# SETUP
registered_user = auth_register('*****@*****.**', '123456', 'John',
'Smith')
token = registered_user['token']
c_id = channel_create(token, 'Channel1', 'true')
# SETUP END
with pytest.raises(ValueError, match=r"*"):
message_send(token, c_id, None)
def test_maximum():
'''
Test sending a message at the maxmium character limit (1000)
'''
reset_data()
# SETUP
registered_user = auth_register('*****@*****.**', '123456', 'John',
'Smith')
token = registered_user['token']
c_id = channel_create(token, 'Channel1', 'true')
# SETUP END
message_send(token, c_id, 'a' * 1000)
message_list = get_messages(c_id)
assert 'a' in message_list[0]['message']
def test_sendlater_nomsg():
'''
Test sending a message later with no message
'''
reset_data()
# SETUP
registered_user = auth_register('*****@*****.**', '123456', 'John',
'Smith')
token = registered_user['token']
c_id = channel_create(token, 'Channel1', 'true')
# SETUP END
time_sent = t.time() + 10
with pytest.raises(ValueError, match=r"*"):
message_sendlater(token, c_id, None, time_sent)
def test_past():
'''
Test sending a message later when the time is in the past
'''
reset_data()
# SETUP
registered_user = auth_register('*****@*****.**', '123456', 'John',
'Smith')
token = registered_user['token']
c_id = channel_create(token, 'Channel1', 'true')
# SETUP END
time_sent = t.time() - 10
with pytest.raises(ValueError, match=r"*"):
message_sendlater(token, c_id, 'Hello world', time_sent)
def test_standup_active_none():
'''
Test standup_active when there is no active standup
'''
reset_data()
# SETUP
registered_user = auth_register('*****@*****.**', '123456', 'John',
'Smith')
token = registered_user['token']
c_id = channel_create(token, 'Channel1', 'true')
# SETUP END
assert standup_active(token, c_id) is None
def test_standupsend_nostandup():
'''
Test standup_send when there is no active standup
'''
reset_data()
# SETUP
registered_user = auth_register('*****@*****.**', '123456', 'John',
'Smith')
token = registered_user['token']
c_id = channel_create(token, 'Channel1', 'true')
# SETUP END
with pytest.raises(ValueError, match=r"*"):
standup_send(token, c_id, 60)
def test_channel_messages():
reset_data()
# SETUP START
token = auth_register('*****@*****.**', 'pass123', 'john', 'apple')['token']
channel_id_public = channel_create(token, 'newChannel', True)
message_send(token, channel_id_public, "firstMessage")
# SETUP END
# Invalid token
with pytest.raises(AccessError, match = r"*"):
channel_messages(123, channel_id_public, 0)
# Invalid channel id
with pytest.raises(ValueError, match = r"*"):
channel_messages(token, 123, 0)
# Working channel messages (less than 50 messages)
assert channel_messages(token, channel_id_public, 0) == [{"messages": "firstMessage", "start" : 0, "end" : -1}]
