rookeries/tests/server/test_site_management.py

"""
Functional tests for the managing sites.

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

import http
from unittest import mock

import pytest_bdd as bdd
import requests
from pytest_bdd import parsers

from tests import utils


# TODO: Rework site management and testing.
# bdd.scenarios('site_access.feature')
# bdd.scenarios('site_modification.feature')


@bdd.given(parsers.parse('I try to create a site'), target_fixture='api_response')
def create_site_response(auth_token_headers, api_base_uri):

    test_site = utils.generate_test_site()
    site_creation_request = {
        'name': test_site.site_name,
        'base_url': test_site.base_url,
    }

    response = requests.post(
        url=f'{api_base_uri}/api/sites/',
        json=site_creation_request,
        headers=auth_token_headers,
    )
    return utils.ResponseSampleBundle(response, test_site)


@bdd.given(parsers.parse('I try to create a site with the same site name'), target_fixture='api_response')
def recreate_existing_site_response(api_response, auth_token_headers, api_base_uri):

    test_site = api_response.sample
    site_creation_request = {
        'name': test_site.site_name,
        'base_url': test_site.base_url,
    }

    response = requests.post(
        url=f'{api_base_uri}/api/sites/',
        json=site_creation_request,
        headers=auth_token_headers,
    )
    return utils.ResponseSampleBundle(response, test_site)


@bdd.given(parsers.parse('I try to create a site with a non-json request'), target_fixture='api_response')
def invalid_non_json_create_site_response(auth_token_headers, api_base_uri):
    return requests.post(
        url=f'{api_base_uri}/api/sites/',
        data='',
        headers=auth_token_headers,
    )


@bdd.given(parsers.parse('I try to create a site with an empty request'), target_fixture='api_response')
def invalid_empty_create_site_response(auth_token_headers, api_base_uri):
    return requests.post(
        url=f'{api_base_uri}/api/sites/',
        json={},
        headers=auth_token_headers,
    )


@bdd.given(parsers.parse('I try to modify the site with a non-json request'), target_fixture='api_response')
def invalid_non_json_modify_site_response(api_response, auth_token_headers, api_base_uri):
    test_site = api_response.sample
    return requests.put(
        url=f'{api_base_uri}/api/sites/{test_site.site_name}',
        data='',
        headers=auth_token_headers,
    )


@bdd.given(parsers.parse('I try to modify the site with an empty request'), target_fixture='api_response')
def invalid_empty_modify_site_response(api_response, auth_token_headers, api_base_uri):
    test_site = api_response.sample
    return requests.put(
        url=f'{api_base_uri}/api/sites/{test_site.site_name}',
        json={},
        headers=auth_token_headers,
    )


@bdd.given(parsers.parse('I get a {state} site'), target_fixture='api_response')
def get_site_request(state, auth_token_headers, api_base_uri, db_engine):

    # TODO: Generate a test site by its state
    test_site = utils.generate_test_site()
    utils.save_test_site_in_db(db_engine, test_site)

    response = requests.get(
        url=f'{api_base_uri}/api/sites/{test_site.site_name}',
        headers=auth_token_headers,
    )
    return utils.ResponseSampleBundle(response, test_site)


@bdd.given(parsers.parse('I get a site that does not exist'), target_fixture='api_response')
def get_non_existent_site_request(auth_token_headers, api_base_uri):
    return requests.get(
        url=f'{api_base_uri}/api/sites/this-does-not-exist',
        headers=auth_token_headers,
    )


@bdd.then(parsers.parse('I get a valid site'))
def assert_site_response(api_response, api_base_uri):

    test_site = api_response.sample
    actual_response = utils.extract_response(api_response)
    assert actual_response.status_code == http.HTTPStatus.OK

    expected_json = {
        'name': test_site.site_name,
        'base_url': test_site.base_url,
        'urls': mock.ANY,
    }
    assert expected_json == actual_response.json()
    assert f'{api_base_uri}/api/sites/{test_site.site_name}' == actual_response.json()['urls']['self']


@bdd.then(parsers.parse('I get a valid new site'))
def assert_new_site_response(api_response, api_base_uri):

    test_site = api_response.sample
    actual_response = utils.extract_response(api_response)
    assert actual_response.status_code == http.HTTPStatus.CREATED

    expected_json = {
        'name': test_site.site_name,
        'base_url': test_site.base_url,
        'urls': mock.ANY,
    }
    assert expected_json == actual_response.json()
    assert f'{api_base_uri}/api/sites/{test_site.site_name}' == actual_response.json()['urls']['self']


@bdd.given(parsers.parse('I try to delete the site'), target_fixture='api_response')
def delete_site_response(api_response, auth_token_headers, api_base_uri):
    test_site = api_response.sample
    response = requests.delete(
        url=f'{api_base_uri}/api/sites/{test_site.site_name}',
        headers=auth_token_headers,
    )
    return utils.ResponseSampleBundle(response, test_site)


@bdd.given(parsers.parse('I try to delete the deleted site again'), target_fixture='api_response')
def delete_deleted_site_response(api_response, auth_token_headers, api_base_uri):
    return delete_site_response(api_response, auth_token_headers, api_base_uri)


@bdd.given(parsers.parse('I try to modify the site'), target_fixture='api_response')
def modify_site_response(api_response, auth_token_headers, api_base_uri):
    test_site = api_response.sample
    modified_base_url = f'{test_site.base_url}/new_'
    modified_site = utils.generate_test_site(test_site.site_name, modified_base_url)
    site_modification_request = {
        'name': test_site.site_name,
        'base_url': modified_base_url,
    }

    response = requests.put(
        url=f'{api_base_uri}/api/sites/{test_site.site_name}',
        json=site_modification_request,
        headers=auth_token_headers,
    )
    return utils.ResponseSampleBundle(response, modified_site)


@bdd.given(parsers.parse('I try to modify a site that does not exist'), target_fixture='api_response')
def modify_non_existent_site_request(auth_token_headers, api_base_uri):
    test_site = utils.generate_test_site()
    site_modification_request = {
        'name': 'this-does-not-exist',
        'base_url': test_site.base_url,
    }

    return requests.put(
        url=f'{api_base_uri}/api/sites/this-does-not-exist',
        json=site_modification_request,
        headers=auth_token_headers,
    )


@bdd.then(parsers.parse('my updates are reflected in the site'))
def assert_updated_site_response(api_response, api_base_uri):

    test_site = api_response.sample
    actual_response = utils.extract_response(api_response)
    assert actual_response.status_code == http.HTTPStatus.OK

    expected_json = {
        'name': test_site.site_name,
        'base_url': test_site.base_url,
        'urls': mock.ANY,
    }
    assert expected_json == actual_response.json()
    assert f'{api_base_uri}/api/sites/{test_site.site_name}' == actual_response.json()['urls']['self']


@bdd.then(parsers.parse('I get a site can not be found message'))
def assert_resource_not_found_response(api_response):
    actual_response = utils.extract_response(api_response)
    expected_response_json = {
        'error': {
            'status_code': http.HTTPStatus.NOT_FOUND.value,
            'message': 'Resource not found.',
            'resource': actual_response.request.url,
        },
    }

    assert actual_response.status_code == http.HTTPStatus.NOT_FOUND
    assert actual_response.json() == expected_response_json