rookeries/api/tests/server/test_user_management.py

"""
Functional tests for the managing users.

:copyright: Copyright 2013-2016, Dorian Pula <dorian.pula@amber-penguin-software.ca>
:license: AGPL v3+
"""

import http

import pytest
import pytest_bdd as bdd
import requests
from pytest import mark
from pytest_bdd import parsers

from rookeries.users import models
from tests import utils

# TODO: Add tests to make sure users can't modify each other's profiles, etc.
# TODO: Add in a new role that is super-admin, maybe?

TEST_USER_PASSWORDS = 'password-testing'


@pytest.fixture(scope='module')
def admin_user(db_engine):
    return utils.create_test_user(
        db_engine=db_engine,
        username='admin',
        password=TEST_USER_PASSWORDS,
        role=models.UserRole.admin,
    )


@pytest.fixture(scope='module')
def editor_user(db_engine):
    return utils.create_test_user(
        db_engine=db_engine,
        username='site-editor',
        password=TEST_USER_PASSWORDS,
        role=models.UserRole.editor,
    )


SAMPLE_USERS_REQUEST = {
    'admin': {},
    'editor': {},
}


@mark.skip(reason="Test scenarios need work")
@bdd.scenario('user_management.feature', 'Admin user can create a new admin user')
def test_admin_user_creation_by_admin():
    pass


@mark.skip(reason="Test scenarios need work")
@bdd.scenario('user_management.feature', 'Admin user can create a new editor user')
def test_editor_user_creation_by_admin():
    pass


@mark.skip(reason="Test scenarios need work")
@bdd.scenario('user_management.feature', 'Editor user can not create a new admin user')
def test_admin_user_creation_by_editor():
    pass


@mark.skip(reason="Test scenarios need work")
@bdd.scenario('user_management.feature', 'Editor user can not create a new editor user')
def test_editor_user_creation_by_editor():
    pass


@bdd.scenario('user_management.feature', 'Admin user can get an existing admin user')
def test_admin_user_fetch_by_admin():
    pass


@bdd.scenario('user_management.feature', 'Admin user can get an existing editor user')
def test_editor_user_fetch_by_admin():
    pass


@mark.skip(reason="Test scenarios need work")
@bdd.scenario('user_management.feature', 'Any user can not get an existing admin user')
def test_admin_user_fetch_by_anyone():
    pass


@mark.skip(reason="Test scenarios need work")
@bdd.scenario('user_management.feature', 'Any user can not get an existing editor user')
def test_editor_user_fetch_by_anyone():
    pass


@mark.skip(reason="FIXME")
@bdd.scenario('user_management.feature', 'Editor user can not get an existing admin user')
def test_admin_user_fetch_by_editor():
    pass


@mark.skip(reason="Test scenarios need work")
@bdd.scenario('user_management.feature', 'Editor user can not get an existing editor user that is not me')
def test_editor_user_fetch_by_editor():
    pass


@mark.skip(reason="Test scenarios need work")
@bdd.scenario('user_management.feature', 'Admin user can modify an admin user')
def test_admin_user_modification_by_admin():
    pass


@mark.skip(reason="Test scenarios need work")
@bdd.scenario('user_management.feature', 'Admin user can modify an editor user')
def test_editor_user_modification_by_admin():
    pass


@mark.skip(reason="Test scenarios need work")
@bdd.scenario('user_management.feature', 'Editor user can not modify an editor user that is not self')
def test_editor_user_modification_by_editor():
    pass


@mark.skip(reason="Test scenarios need work")
@bdd.scenario('user_management.feature', 'Editor user can modify their own user')
def test_self_user_modification_by_editor():
    pass


@mark.skip(reason="Test scenarios need work")
@bdd.scenario('user_management.feature', 'Admin user can delete an admin user')
def test_admin_user_deletion_by_admin():
    pass


@mark.skip(reason="Test scenarios need work")
@bdd.scenario('user_management.feature', 'Admin user can delete an editor user')
def test_editor_user_deletion_by_admin():
    pass


@mark.skip(reason="Test scenarios need work")
@bdd.scenario('user_management.feature', 'Editor user can not delete an editor user')
def test_editor_user_deletion_by_editor():
    pass


# Step definitions here.

@bdd.given(parsers.parse('I am an {user_role} user'))
def jwt_token(user_role, api_base_uri, admin_user, editor_user):

    # TODO: Improve selection of fixtures.
    user_info = None
    if user_role == models.UserRole.admin.name:
        user_info = admin_user
    elif user_role == models.UserRole.editor.name:
        user_info = editor_user

    jwt_token = requests.post(
        url=f'{api_base_uri}/auth',
        json={
            'username': user_info['username'],
            'password': TEST_USER_PASSWORDS,
        }
    ).json()['access_token']
    return jwt_token


@bdd.given(parsers.parse('I create an {user_role} user'))
def create_user_response(user_role, jwt_token, api_base_uri):
    user_creation_request = SAMPLE_USERS_REQUEST[user_role]
    response = requests.post(
        url=f'{api_base_uri}/api/users',
        json=user_creation_request,
        headers={
            'Authorization': f'JWT {jwt_token}',
        },
    )

    return response


@bdd.given(parsers.parse('I get an {user_role} user'))
def get_user_response(user_role, jwt_token, api_base_uri, admin_user, editor_user):

    test_user = None
    if user_role == models.UserRole.admin.name:
        test_user = admin_user
    elif user_role == models.UserRole.editor.name:
        test_user = editor_user

    response = requests.get(
        url=f'{api_base_uri}/api/users/{test_user["username"]}',
        headers={
            'Authorization': f'JWT {jwt_token}',
        },
    )
    return response


@bdd.then(parsers.parse('I get a new {user_role} user'))
def assert_create_user_response(user_role, create_user_response, admin_user, editor_user):
    assert create_user_response.status_code == http.HTTPStatus.CREATED
    expected_user_creation_response = admin_user
    assert create_user_response.json() == expected_user_creation_response


@bdd.then(parsers.parse('I can get an {user_role} user profile'))
def assert_user_profile(user_role, get_user_response, admin_user, editor_user):

    # TODO: Add in actual user profiles...
    test_user = None
    if user_role == models.UserRole.admin.name:
        test_user = admin_user
    elif user_role == models.UserRole.editor.name:
        test_user = editor_user

    assert get_user_response.status_code == http.HTTPStatus.OK
    expected_user_creation_response = test_user
    assert get_user_response.json() == expected_user_creation_response


@bdd.then(parsers.parse('I get an unauthorized response'))
def assert_unauthorized_response(get_user_response: requests.Response):
    assert get_user_response.status_code == http.HTTPStatus.UNAUTHORIZED

    expected_response_json = {
        'status_code': http.HTTPStatus.UNAUTHORIZED,
        'error': 'Unauthorized',
        'description': 'Not authorized to access this resource.',
        'resource': get_user_response.request.url,
    }
    assert get_user_response.json() == expected_response_json