コード例 #1
0
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)
コード例 #2
0
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",
                                                              }
コード例 #3
0
def test_user_profile_setemail():
    helper.reset_data()
    # SETUP START
    admin = helper.token_admin()
    token = admin["token"]
    profile_dict = stub.user_profile(admin["token"], admin["u_id"])
    curr_email = profile_dict['email']
    # New email
    new_email = "*****@*****.**"
    # Used email
    used_email = "*****@*****.**"
    # Invalid email
    invalid_email = "user.com"
    # SETUP END

    # Checks that it raises an error for used emails
    with pytest.raises(validation_helper.ValueError):
        stub.user_profile_setemail(token, used_email)

    # Checks that it raises an error for invalid emails
    with pytest.raises(validation_helper.ValueError):
        stub.user_profile_setemail(token, invalid_email)

    # Checks that the function has successfully changed valid email
    stub.user_profile_setemail(token, new_email)
    assert curr_email != new_email
コード例 #4
0
def test_channels_create():
    helper.reset_data()
    user = helper.token_admin()

    # Invalid token
    with pytest.raises(validation_helper.AccessError):
        stub.channels_create("fake token", "name", True)

    with pytest.raises(validation_helper.ValueError):
        # check that validation_helper.ValueError is raised if name is more than 20 characters long
        stub.channels_create(user["token"], "123456789012345678901", True)

    with pytest.raises(validation_helper.ValueError):
        # check that validation_helper.ValueError is raised if name is an empty string (assumption)
        stub.channels_create(user["token"], "", True)

    # check that call is successful otherwise
    public_channel_id = stub.channels_create(user["token"], "Public Channel", True)["channel_id"]
    private_channel_id = stub.channels_create(user["token"], "Private Channel", False)["channel_id"]

    assert stub.channels_listall(user["token"]) == {
        "channels": [
            {"channel_id": public_channel_id, "name": "Public Channel"},
            {"channel_id": private_channel_id, "name": "Private Channel"}
        ]
    }
コード例 #5
0
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
コード例 #6
0
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"}]}
コード例 #7
0
def test_user_profiles_uploadphoto():
    helper.reset_data()
    # SETUP START
    admin = helper.token_admin()
    token = admin["token"]
    img_url = "https://data.junkee.com/wp-content/uploads/2018/04/peppapig-680x454.jpg"
    x_start = 0
    y_start = 0
    x_end = 100
    y_end = 100
    # Invalid Inputs
    invalidx_start = -1
    invalidx_end = -1
    largex_start = 1000000
    largex_end = 1000000
    invalid_img = "https://www.peppapig.com/wp-content/uploads/sites/3/2019/02/peppa_pig_splat.png"

    # Checks that it raises an error for invalid bounds
    with pytest.raises(validation_helper.ValueError):
        stub.user_profiles_uploadphoto(token, img_url, invalidx_start, y_start, invalidx_end, y_end)

    # Checks that it raises an error for HTTP other than 200
    with pytest.raises(validation_helper.ValueError):
        stub.user_profiles_uploadphoto(token, invalid_img, x_start, y_start, x_end, y_end)

    # Checks that it raises an error if bounds are not within image dimensions
    with pytest.raises(validation_helper.ValueError):
        stub.user_profiles_uploadphoto(token, img_url, largex_start, y_start, largex_end, y_end)

    # Checks that valid profile photo is updated
    stub.user_profiles_uploadphoto(token, img_url, x_start, y_start, x_end, y_end)
コード例 #8
0
def test_user_profile_sethandle():
    helper.reset_data()
    # SETUP START
    admin = helper.token_admin()
    admin_profile_dict = stub.user_profile(admin["token"], admin["u_id"])
    curr_handle = admin_profile_dict["handle_str"]
    new_handle = 'pig_daddy'
    # Invalid handle with >20 characters
    max_handle = 'a' * 21
    # Invalid handle with no valid characters
    invalid_handle = '??'
    # Invalid handle with no input
    no_handle = ' '
    # SETUP END

    # Checks that an error is raised for >20 characters
    with pytest.raises(validation_helper.ValueError):
        stub.user_profile_sethandle(admin["token"], max_handle)

    # Checks that an error is raised for invalid characters
    with pytest.raises(validation_helper.ValueError):
        stub.user_profile_sethandle(admin["token"], invalid_handle)

    # Checks that an error is raised for no characters
    with pytest.raises(validation_helper.ValueError):
        stub.user_profile_sethandle(admin["token"], no_handle)

    # Successfully updated the handle
    stub.user_profile_sethandle(admin["token"], new_handle)
    assert curr_handle != new_handle
コード例 #9
0
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)
コード例 #10
0
def test_standup_send():
    helper.reset_data()
    # SETUP START
    admin = helper.token_admin()
    token = admin["token"]
    channel_id = helper.channelid_public(token)
    text = "Hi"
    stub.standup_start(token, channel_id, 5)
    # Invalid inputs
    invalid_channel_id = -111111
    invalid_text = 'Hi' * 1001
    # SETUP END

    # Checks that it raises an error when the channel ID does not exit
    with pytest.raises(validation_helper.ValueError):
        stub.standup_send(token, invalid_channel_id, text)

    # Checks that it raises an error for > 1000 characters
    with pytest.raises(validation_helper.ValueError):
        stub.standup_send(token, channel_id, invalid_text)

    # Successfully send a message in a standup
    assert stub.standup_send(token, channel_id, text) == {}

    # Checks that it raises an error when user is not part of the channel
    with pytest.raises(validation_helper.AccessError):
        stub.channel_leave(admin["token"], channel_id)
        stub.standup_send(admin["token"], channel_id, text)

    # Checks that it raises an error if the standup time has stopped
    with pytest.raises(validation_helper.AccessError):
        time.sleep(6)
        stub.standup_send(token, channel_id, text)
コード例 #11
0
def test_standup_start():
    helper.reset_data()
    # SETUP START
    admin = helper.token_admin()
    token = admin["token"]
    channel_id = helper.channelid_public(token)
    # Invalid channel id
    invalid_channel_id = -111111
    # SETUP END

    # Check that error is raised if an invalid token is passed in
    with pytest.raises(validation_helper.AccessError):
        stub.standup_start("fake token", channel_id, 10)

    # Checks that it raises an error when channel id does not exist
    with pytest.raises(validation_helper.ValueError):
        stub.standup_start(token, invalid_channel_id, 10)

    # Checks that a standup has successfully started
    time_check = get_info_helper.get_serializable_datetime(datetime.now() + timedelta(seconds=6))

    assert stub.standup_start(token, channel_id, 5)["time_finish"] < time_check

    # Checks that it raises an error when the user is not part of the channel
    with pytest.raises(validation_helper.AccessError):
        stub.channel_leave(admin["token"], channel_id)
        stub.standup_start(token, channel_id, 10)
コード例 #12
0
def test_user_profile_setname():
    helper.reset_data()
    # SETUP START
    admin = helper.token_admin()
    token = admin["token"]
    profile_dict = stub.user_profile(token, admin["u_id"])
    curr_first = profile_dict['name_first']
    curr_last = profile_dict['name_last']
    # Set names to the following
    new_first = "George"
    new_last = "pig"
    # Invalid input with >50 characters
    invalid_name = "a" * 51
    # Invalid input that aren't words
    jibberish = '??[45jibbersh'
    no_input = ' '
    # Channel to be used in last test
    channel_id = helper.channelid_public(token)
    # SETUP END

    # Checks that an error is raised for > 50 characters
    with pytest.raises(validation_helper.ValueError):
        stub.user_profile_setname(token, invalid_name, invalid_name)

    # Checks that an error is raised for no input
    with pytest.raises(validation_helper.ValueError):
        stub.user_profile_setname(token, new_first, no_input)

    # Checks that an error is raised for not valid characters
    with pytest.raises(validation_helper.ValueError):
        stub.user_profile_setname(token, new_first, jibberish)

    # Checks that the name is updated if its <= 50 characters
    stub.user_profile_setname(admin["token"], new_first, new_last)
    assert(curr_first != new_first and curr_last != new_last)
    new_dict = stub.user_profile(admin["token"], admin["u_id"])
    assert new_dict['name_first'] == new_first and new_dict['name_last'] == new_last

    # Checks that name has also been updated in the channel
    assert stub.channel_details(token, channel_id)["all_members"] == [{
                                                                        "u_id": admin["u_id"],
                                                                        "name_first": new_first,
                                                                        "name_last": new_last,
                                                                        "profile_img_url": "/static/default.jpg"
                                                                    }]
    assert stub.channel_details(token, channel_id)["owner_members"] == [{
                                                                        "u_id": admin["u_id"],
                                                                        "name_first": new_first,
                                                                        "name_last": new_last,
                                                                        "profile_img_url": "/static/default.jpg"
                                                                        }]
コード例 #13
0
def test_search():
    helper.reset_data()
    # SETUP START
    admin = helper.token_admin()
    channel_id = helper.channelid_public(admin["token"])
    keyword = "Hello" + str(random())
    # SETUP END

    # Checks that nothing is returned if the message does not exist
    assert stub.search(admin["token"], "this message does not exist" + str(random())) == {"messages": []}

    # Checks that messages are successfully returned
    stub.message_send(admin["token"], channel_id, keyword)
    assert keyword in stub.search(admin["token"], keyword)["messages"][0]["message"]
コード例 #14
0
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
コード例 #15
0
def test_standup_active():
    helper.reset_data()
    # SETUP START
    admin = helper.token_admin()
    channel_id = helper.channelid_public(admin["token"])
    # SETUP END

    # Check that error is raised if an invalid token is passed in
    with pytest.raises(validation_helper.AccessError):
        stub.standup_active("fake token", channel_id)

    # Checks that it raises an error when channel does not exit
    with pytest.raises(validation_helper.ValueError):
        stub.standup_active(admin["token"], -1)

    # Check when there is no standup
    assert stub.standup_active(admin["token"], channel_id) == {"is_active": False, "time_finish": None}

    # Check when there is a standup
    stub.standup_start(admin["token"], channel_id, 3)
    assert stub.standup_active(admin["token"], channel_id)["is_active"] is True
コード例 #16
0
def test_channel_leave():
    helper.reset_data()
    # SETUP START
    user = helper.token_admin()
    new_channel_id = helper.channelid_public(user["token"])
    # SETUP END

    # Check that error is raised if an invalid token is passed in
    with pytest.raises(validation_helper.AccessError):
        stub.channel_leave("fake token", new_channel_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_leave(user["token"], -1)

    # check that call is successful if channel exists and user is a member of it
    stub.channel_leave(user["token"], new_channel_id)
    assert validation_helper.is_member(user["u_id"], new_channel_id) is not True

    # check that nothing happens if user is not in the channel (assumption)
    stub.channel_leave(user["token"], new_channel_id)  # should raise no errors
コード例 #17
0
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)
コード例 #18
0
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"},
        ]
    }