def test_message_send(): helper.reset_data() # Valid parameters token = helper.token_account_1()["token"] channel_id = helper.get_valid_channel(token) message = "Testing the function message_send." # Invalid parameters invalid_channel_id = -00000 invalid_message = message*3000 unauthorised_token = helper.token_account_2()["token"] # Test that it raises an erorr if the channel does not exist with pytest.raises(validation_helper.ValueError): stub.message_send(token, invalid_channel_id, message) # Test that it raises an erorr if the message is >1000 characters with pytest.raises(validation_helper.ValueError): stub.message_send(token, channel_id, invalid_message) # Test that it raises an access erorr if the token is not an authorised user. # Note: we assume the second account is not part of the channel. This will fail if the second # account is in the channel with pytest.raises(validation_helper.AccessError): stub.channel_leave(unauthorised_token, channel_id) stub.message_send(unauthorised_token, channel_id, message) # Test that the function successfully completes with valid parameters # (this may require manual verification) assert stub.message_send(token, channel_id, message)["message_id"] > -1
def test_message_remove(): helper.reset_data() # Valid parameters token = helper.token_account_1()["token"] channel_id = helper.get_valid_channel(token) message_id = helper.get_valid_message(token, channel_id) message = "This message was produced by the get_valid_message function." # Invalid parameters unauthorised_token = helper.token_account_2()["token"] stub.channel_leave(unauthorised_token, channel_id) # Test that it raises an access erorr if the user is not in the channel # to remove a message with pytest.raises(validation_helper.AccessError): stub.message_remove(unauthorised_token, message_id) # Test that it raises an access erorr if the user does not have the proper # authority to remove a message with pytest.raises(validation_helper.AccessError): stub.channel_join(unauthorised_token, channel_id) stub.message_remove(unauthorised_token, message_id) # Attempt to successfully remove a message assert stub.message_remove(token, message_id) == {} # Test that it raises an error if trying to remove a already removed message with pytest.raises(validation_helper.ValueError): stub.message_remove(token, message_id) # Test that the message disappears from search assert message_id not in stub.search(token, message)
def test_message_unreact(): helper.reset_data() # Set up valid parameters token = helper.token_account_1()["token"] react_id = 1 # We do not have any way of obtaining a valid react_id atm channel_id = helper.get_valid_channel(token) message_id = helper.get_valid_message(token, channel_id) stub.message_react(token, message_id, react_id) # Set up invalid parameters invalid_react_id = -1 invalid_message_id = -1 # message_id is invalid with pytest.raises(validation_helper.ValueError): stub.message_unreact(token, invalid_message_id, react_id) # react_id is not a valid React ID with pytest.raises(validation_helper.ValueError): stub.message_unreact(token, invalid_message_id, invalid_react_id) # successfully unreact a message assert stub.message_unreact(token, message_id, react_id) == {} # unreact something you already unreacted with pytest.raises(validation_helper.ValueError): stub.message_unreact(token, message_id, react_id)
def test_channel_invite(): helper.reset_data() # Create users for testing user1 = helper.token_account_1() user2 = helper.token_account_2() # create a new channel for testing channel_id = helper.channelid_public(user1["token"]) # Check that error is raised if an invalid token is passed in with pytest.raises(validation_helper.AccessError): stub.channel_invite("fake token", channel_id, user1["u_id"]) # Invalid channel_id with pytest.raises(validation_helper.ValueError): stub.channel_invite(user1["token"], -1, user2["u_id"]) # Invalid u_id with pytest.raises(validation_helper.ValueError): stub.channel_invite(user1["token"], channel_id, -1) # valid call assert stub.channel_invite(user1["token"], channel_id, user2["u_id"]) == {} # Test that the user is in the channel message_id = stub.message_send(user2["token"], channel_id, "Hi")["message_id"] # check that nothing happens if the user is already in the channel stub.channel_invite(user1["token"], channel_id, user1["u_id"]) # check that if an admin/owner of the slackr is invited, they become an owner stub.channel_leave(user1["token"], channel_id) stub.channel_invite(user2["token"], channel_id, user1["u_id"]) stub.message_remove(user1["token"], message_id) # can do this since they should be an owner
def test_channel_removeowner(): helper.reset_data() # SETUP START user1 = helper.token_admin() user2 = helper.token_account_1() new_channel_id = helper.channelid_public(user1["token"]) # SETUP END # Check that error is raised if an invalid token is passed in with pytest.raises(validation_helper.AccessError): stub.channel_removeowner("fake token", new_channel_id, user1["u_id"]) with pytest.raises(validation_helper.ValueError): # check that validation_helper.ValueError is raised if channel does not exist # Assumption: channel_id cannot be negative stub.channel_removeowner(user1["token"], -1, user1["u_id"]) with pytest.raises(validation_helper.ValueError): # Check ValueError raised if target user is not an owner stub.channel_removeowner(user1["token"], new_channel_id, user2["u_id"]) with pytest.raises(validation_helper.AccessError): # Check accessError raised if user not an owner stub.channel_removeowner(user2["token"], new_channel_id, user1["u_id"]) with pytest.raises(validation_helper.AccessError): # Check accessError raised if target is an owner stub.channel_removeowner(user1["token"], new_channel_id, user1["u_id"]) # Check that call is successful if all inputs are valid stub.channel_addowner(user1["token"], new_channel_id, user2["u_id"]) stub.channel_removeowner(user1["token"], new_channel_id, user2["u_id"]) assert validation_helper.is_owner(user2["u_id"], new_channel_id) is not True
def test_channels_list(): helper.reset_data() # SETUP START user1 = helper.token_admin() user2 = helper.token_account_1() channel1_id = helper.channelid_public(user1["token"]) channel2_id = helper.channelid_private(user1["token"]) # SETUP END assert stub.channels_list(user1["token"]) == { "channels": [ {"channel_id": channel1_id, "name": "Public Channel"}, {"channel_id": channel2_id, "name": "Private Channel"} ] } # Invalid token with pytest.raises(validation_helper.AccessError): stub.channels_list("fake token") # check that no channels are returned if user is not in any channel assert stub.channels_list(user2["token"]) == {"channels": []} stub.channel_join(user2["token"], channel1_id) # check that output changes once a user joins a channel assert stub.channels_list(user2["token"]) == {"channels": [{"channel_id": channel1_id, "name": "Public Channel"}]} # check that output changes once a user leaves a channel stub.channel_leave(user1["token"], channel1_id) assert stub.channels_list(user1["token"]) == {"channels": [{"channel_id": channel2_id, "name": "Private Channel"}]}
def test_message_unpin(): helper.reset_data() # Set up valid parameters token = helper.token_admin()["token"] not_admin = helper.token_account_1()["token"] channel_id = helper.get_valid_channel(not_admin) message_id = helper.get_valid_message(not_admin, channel_id) stub.channel_join(token, channel_id) stub.message_pin(token, message_id) # Set up invalid parameters invalid_message_id = -1 # message_id is not a valid message with pytest.raises(validation_helper.ValueError): stub.message_unpin(token, invalid_message_id) # Error when the authorised user is not an admin with pytest.raises(validation_helper.ValueError): stub.message_unpin(not_admin, message_id) # Error when the admin is not a member of the channel that the message is within with pytest.raises(validation_helper.AccessError): stub.channel_leave(token, channel_id) stub.message_unpin(channel_id, message_id) stub.channel_join(token, channel_id) # successfully unpin a message assert stub.message_unpin(token, message_id) == {} # try and unpin a message again with pytest.raises(validation_helper.ValueError): stub.message_unpin(token, message_id)
def test_user_profile(): helper.reset_data() # SETUP START admin = helper.token_admin() user = helper.token_account_1() # Invalid User invalid_token = "invalidTest" invalid_user = -1 # SETUP END # Checks that an error is raised for invalid token with pytest.raises(validation_helper.AccessError): stub.user_profile(invalid_token, user["u_id"]) # Checks that an error is raised for invalid user with pytest.raises(validation_helper.ValueError): stub.user_profile(admin["token"], invalid_user) # Checks that the correct user profile is returned assert stub.user_profile(admin["token"], admin["u_id"]) == {"u_id": admin["u_id"], "email": "*****@*****.**", "name_first": "Daddy", "name_last": "Pig", "handle_str": "daddypig", "profile_img_url": "/static/default.jpg", } assert stub.user_profile(user["token"], user["u_id"]) == {"u_id": user["u_id"], "email": "*****@*****.**", "name_first": "Mommy", "name_last": "Pig", "handle_str": "mommypig", "profile_img_url": "/static/default.jpg", }
def test_message_react(): helper.reset_data() # Valid parameters token = helper.token_account_1()["token"] react_id = 1 # We do not have any way of obtaining a valid react_id atm channel_id = helper.get_valid_channel(token) message_id = helper.get_valid_message(token, channel_id) # Invalid parameters invalid_react_id = -1 invalid_message_id = -1 # message_id is not a valid message within a channel that the authorised user has joined with pytest.raises(validation_helper.ValueError): stub.message_react(token, invalid_message_id, react_id) # react_id is not a valid React ID with pytest.raises(validation_helper.ValueError): stub.message_react(token, message_id, invalid_react_id) # Successfully react a message assert stub.message_react(token, message_id, react_id) == {} # Message with ID message_id already contains an active React with ID react_id with pytest.raises(validation_helper.ValueError): stub.message_react(token, message_id, react_id)
def test_admin_userpermission_change(): helper.reset_data() user1 = helper.token_admin() user2 = helper.token_account_1() # Invalid token with pytest.raises(validation_helper.AccessError): stub.admin_userpermission_change("fake token", user2["u_id"], 2) with pytest.raises(validation_helper.ValueError): # check that validation_helper.ValueError is raised if u_id is not valid # Assumption: u_ids cannot be negative stub.admin_userpermission_change(user1["token"], -1, 2) with pytest.raises(validation_helper.ValueError): # check that validation_helper.ValueError is raised if permission_id is not valid stub.admin_userpermission_change(user1["token"], user1["u_id"], 10) # check that function can run if all inputs are valid stub.admin_userpermission_change(user1["token"], user2["u_id"], 1) # if previous call was successful, user2 should be able to change their own permissions # Assumption: users can change their own permissions provided they are currently an admin stub.admin_userpermission_change(user2["token"], user2["u_id"], 3) with pytest.raises(validation_helper.AccessError): # check that validation_helper.AccessError is raised if user is not an admin or owner # this should raise an error since user2 has removed their own permissions stub.admin_userpermission_change(user2["token"], user1["u_id"], 3)
def test_channel_messages(): helper.reset_data() # Create users for testing user1 = helper.token_account_1() user1_token = user1["token"] user2 = helper.token_account_2() user2_token = user2["token"] # Create a new channel for testing channel_id = helper.channelid_public(user1_token) # Leave the channel in case user2 is in the new channel stub.channel_leave(user2_token, channel_id) # Setting the start & end start = 0 # Check that error is raised if an invalid token is passed in with pytest.raises(validation_helper.AccessError): stub.channel_messages("fake token", channel_id, start) # Start is a invalid number with pytest.raises(validation_helper.ValueError): stub.channel_messages(user1_token, channel_id, -1) # Channel doesn't exist with pytest.raises(validation_helper.ValueError): stub.channel_messages(user1_token, -1, start) # Index of start greater then messages in channel with pytest.raises(validation_helper.ValueError): stub.channel_messages(user1_token, channel_id, 1000) # user2 is not a member with pytest.raises(validation_helper.AccessError): stub.channel_messages(user2_token, channel_id, start) # valid call message_id = helper.get_valid_message(user1_token, channel_id) message = get_info_helper.get_info_about_message(message_id) assert stub.channel_messages(user1_token, channel_id, start) == {"messages": [message], "start": 0, "end": -1} # now test it with >50 messages sent in the channel i = 0 while i < 70: stub.message_send(user1_token, channel_id, "Hello") i += 1 messages = stub.channel_messages(user1_token, channel_id, 10) assert messages["start"] == 10 assert messages["end"] == 60 assert len(messages["messages"]) == 50
def test_users_all(): helper.reset_data() # Check that error is raised if an invalid token is passed in with pytest.raises(validation_helper.AccessError): stub.users_all("fake token") user1 = helper.token_admin() # Check successful call users = stub.users_all(user1["token"])["users"] assert len(users) == 1 assert users[0]["email"] == "*****@*****.**" assert users[0]["name_last"] == "Pig" # Check that the list changes when a new person registers user2 = helper.token_account_1() users = stub.users_all(user1["token"])["users"] assert len(users) == 2
def test_channel_details(): helper.reset_data() # Create users for testing user1 = helper.token_account_1() user1_token = user1["token"] user1_id = user1["u_id"] user2 = helper.token_account_2() user2_token = user2["token"] # Create a new channel for testing channel_id = helper.channelid_public(user1_token) # this is to test things channel_name = "Public Channel" channel_owner_members = [{"name_first": "Mommy", "name_last": "Pig", "u_id": user1_id, "profile_img_url": "/static/default.jpg"}] channel_all_members = [{"name_first": "Mommy", "name_last": "Pig", "u_id": user1_id, "profile_img_url": "/static/default.jpg"}] # Check that error is raised if an invalid token is passed in with pytest.raises(validation_helper.AccessError): stub.channel_details("fake token", channel_id) # Channel doesn't exist with pytest.raises(validation_helper.ValueError): stub.channel_details(user1_token, -1) # user2 is not a member with pytest.raises(validation_helper.AccessError): stub.channel_details(user2_token, channel_id) # Valid call assert stub.channel_details(user1_token, channel_id) == {"name": channel_name, "owner_members": channel_owner_members, "all_members": channel_all_members}
def test_channel_join(): helper.reset_data() # SETUP START user1 = helper.token_admin() user2 = helper.token_account_1() public_channel_id = helper.channelid_public(user1["token"]) private_channel_id = helper.channelid_private(user1["token"]) # SETUP END # Check that error is raised if an invalid token is passed in with pytest.raises(validation_helper.AccessError): stub.channel_join("fake token", public_channel_id) # Check that error is raised if an invalid channel_id is passed in with pytest.raises(validation_helper.ValueError): stub.channel_join(user1["token"], -1) with pytest.raises(validation_helper.ValueError): # check that validation_helper.ValueError is raised if channel does not exist # Assumption: channel_id cannot be negative stub.channel_join(user1["token"], -1) # check that nothing happens if user is already a member of the channel (assumption) stub.channel_join(user1["token"], public_channel_id) # should raise no errors # check that channel_join is successful when channel is public stub.channel_join(user2["token"], public_channel_id) assert validation_helper.is_member(user2["u_id"], public_channel_id) with pytest.raises(validation_helper.AccessError): # check that validation_helper.AccessError is raised if channel # is private and user is not an admin stub.channel_join(user2["token"], private_channel_id) # check that channel_join is successful when channel is private and user is an admin stub.admin_userpermission_change(user1["token"], user2["u_id"], 2) stub.channel_join(user2["token"], private_channel_id) assert validation_helper.is_member(user2["u_id"], private_channel_id)
def test_channels_listall(): helper.reset_data() # SETUP START user1 = helper.token_admin() user2 = helper.token_account_1() # SETUP END # check that no channels are returned when none exist assert stub.channels_list(user2["token"]) == {"channels": []} # MORE SETUP public_channel_id = helper.channelid_public(user1["token"]) private_channel_id = helper.channelid_private(user1["token"]) # check that both private and public channels are returned assert stub.channels_listall(user1["token"]) == { "channels": [ {"channel_id": public_channel_id, "name": "Public Channel"}, {"channel_id": private_channel_id, "name": "Private Channel"}, ] } # check that all public channels are returned even if the user is not in them # Assumption: private channels are not listed if the user is not in them and not an admin assert stub.channels_listall(user2["token"]) == { "channels": [{"channel_id": public_channel_id, "name": "Public Channel"}], } # check that private channels are returned even if the user is not in them, # provided that the user is an admin stub.channel_leave(user1["token"], private_channel_id) assert stub.channels_listall(user1["token"]) == { "channels": [ {"channel_id": public_channel_id, "name": "Public Channel"}, {"channel_id": private_channel_id, "name": "Private Channel"}, ] }
def test_message_edit(): helper.reset_data() # Valid parameters token = helper.token_account_1()["token"] channel_id = helper.get_valid_channel(token) message_id = helper.get_valid_message(token, channel_id) message = "This message was edited by the message_edit function." # Invalid parameters invalid_message = message*3000 invalid_message_id = -1 unauthorised_token = helper.token_account_2()["token"] # Test that it raises an error if a user edits a message that is not theirs. with pytest.raises(validation_helper.AccessError): stub.channel_join(unauthorised_token, channel_id) stub.message_edit(unauthorised_token, message_id, message) stub.channel_leave(unauthorised_token, channel_id) # Test that it raises an error if invalid message_id with pytest.raises(validation_helper.ValueError): stub.message_edit(token, invalid_message_id, message) # Test that it raises an error if it is a invalid message being edited with pytest.raises(validation_helper.ValueError): stub.message_edit(token, message_id, invalid_message) # Attempt to successfully edit a message assert stub.message_edit(token, message_id, message) == {} # Test that the message is edited in search assert stub.search(token, message)["messages"] != [] # Test that message is deleted if edited with an empty string stub.message_edit(token, message_id, "") assert stub.channel_messages(token, channel_id, 0)["messages"] == []
def test_message_sendlater(): helper.reset_data() # Valid parameters token = helper.token_account_1()["token"] channel_id = helper.get_valid_channel(token) message = "Testing the function message_sendlater." time_sent = helper.in_one_second() # Invalid parameters unauthorised_token = helper.token_account_2()["token"] invalid_channel_id = -00000 invalid_message = message*3000 invalid_time_sent = datetime(2018, 12, 12) stub.channel_leave(unauthorised_token, channel_id) # Test that it raises a error if the channel does not exist with pytest.raises(validation_helper.ValueError): stub.message_sendlater(token, invalid_channel_id, message, time_sent) # Test that it raises an error if the message is >1000 characters with pytest.raises(validation_helper.ValueError): stub.message_sendlater(token, channel_id, invalid_message, time_sent) # Test that it raises an error if the time sent is a time in the past with pytest.raises(validation_helper.ValueError): stub.message_sendlater(token, channel_id, message, invalid_time_sent) # Test that it raises an access error if the token is not an authorised user with pytest.raises(validation_helper.AccessError): stub.message_sendlater(unauthorised_token, channel_id, message, time_sent) # Test that the function successfully completes with valid parameters # (this may require manual verification) message_id = stub.message_sendlater(token, channel_id, message, time_sent)["message_id"] assert message_id > -1