notifications-admin/tests/conftest.py

import os
from datetime import date

import pytest
from alembic.command import upgrade
from alembic.config import Config
from flask.ext.migrate import Migrate, MigrateCommand
from flask.ext.script import Manager
from sqlalchemy.schema import MetaData

from app import create_app, db
from . import (
    create_test_user, service_json, TestClient,
    get_test_user, template_json, api_key_json)


@pytest.fixture(scope='session')
def app_(request):
    app = create_app('test')

    ctx = app.app_context()
    ctx.push()

    def teardown():
        ctx.pop()

    request.addfinalizer(teardown)
    app.test_client_class = TestClient
    return app


@pytest.fixture(scope='session')
def db_(app_, request):
    Migrate(app_, db)
    Manager(db, MigrateCommand)
    BASE_DIR = os.path.dirname(os.path.dirname(__file__))
    ALEMBIC_CONFIG = os.path.join(BASE_DIR, 'migrations')
    config = Config(ALEMBIC_CONFIG + '/alembic.ini')
    config.set_main_option("script_location", ALEMBIC_CONFIG)

    with app_.app_context():
        upgrade(config, 'head')

    def teardown():
        db.session.remove()
        db.drop_all()
        db.engine.execute("drop table alembic_version")
        db.get_engine(app_).dispose()

    request.addfinalizer(teardown)


@pytest.fixture(scope='function')
def db_session(request):
    def teardown():
        db.session.remove()
        for tbl in reversed(meta.sorted_tables):
            if tbl.fullname not in ['roles']:
                db.engine.execute(tbl.delete())

    meta = MetaData(bind=db.engine, reflect=True)
    request.addfinalizer(teardown)


@pytest.fixture(scope='function')
def service_one(request, active_user):
    return service_json(1, 'service one', [active_user.id])


@pytest.fixture(scope='function')
def active_user(request, db_, db_session):
    usr = get_test_user()
    if usr:
        return usr
    return create_test_user('active')


@pytest.fixture(scope='function')
def mock_send_sms(request, mocker):
    return mocker.patch("app.notifications_api_client.send_sms")


@pytest.fixture(scope='function')
def mock_send_email(request, mocker):
    return mocker.patch("app.notifications_api_client.send_email")


@pytest.fixture(scope='function')
def mock_get_service(mocker, active_user):
    def _create(service_id):
        service = service_json(
            service_id, "Test Service", [active_user.id], limit=1000,
            active=False, restricted=True)
        return {'data': service, 'token': 1}

    return mocker.patch('app.notifications_api_client.get_service', side_effect=_create)


@pytest.fixture(scope='function')
def mock_create_service(mocker):
    def _create(service_name, active, limit, restricted, user_id):
        service = service_json(
            101, service_name, [user_id], limit=limit,
            active=active, restricted=restricted)
        return {'data': service}

    mock_class = mocker.patch(
        'app.notifications_api_client.create_service', side_effect=_create)
    return mock_class


@pytest.fixture(scope='function')
def mock_update_service(mocker):
    def _update(service_id,
                service_name,
                active,
                limit,
                restricted,
                users):
        service = service_json(
            service_id, service_name, users, limit=limit,
            active=active, restricted=restricted)
        return {'data': service}

    mock_class = mocker.patch(
        'app.notifications_api_client.update_service', side_effect=_update)
    return mock_class


@pytest.fixture(scope='function')
def mock_get_services(mocker, active_user):
    def _create():
        service_one = service_json(
            1, "service_one", [active_user.id], 1000, True, False)
        service_two = service_json(
            2, "service_two", [active_user.id], 1000, True, False)
        return {'data': [service_one, service_two]}

    mock_class = mocker.patch(
        'app.notifications_api_client.get_services', side_effect=_create)
    return mock_class


@pytest.fixture(scope='function')
def mock_delete_service(mocker, mock_get_service):
    def _delete(service_id):
        return mock_get_service.side_effect(service_id)

    mock_class = mocker.patch(
        'app.notifications_api_client.delete_service', side_effect=_delete)
    return mock_class


@pytest.fixture(scope='function')
def mock_get_service_template(mocker):
    def _create(service_id, template_id):
        template = template_json(
            template_id, "Template Name", "sms", "template content", service_id)
        return {'data': template}

    return mocker.patch(
        'app.notifications_api_client.get_service_template',
        side_effect=_create)


@pytest.fixture(scope='function')
def mock_create_service_template(mocker):
    def _create(name, type_, content, service):
        template = template_json(
            101, name, type_, content, service)
        return {'data': template}

    mock_class = mocker.patch(
        'app.notifications_api_client.create_service_template',
        side_effect=_create)
    return mock_class


@pytest.fixture(scope='function')
def mock_update_service_template(mocker):
    def _update(id_, name, type_, content, service):
        template = template_json(
            id_, name, type_, content, service)
        return {'data': template}

    mock_class = mocker.patch(
        'app.notifications_api_client.update_service_template',
        side_effect=_update)
    return mock_class


@pytest.fixture(scope='function')
def mock_get_service_templates(mocker):
    def _create(service_id):
        template_one = template_json(
            1, "template_one", "sms", "template one content", service_id)
        template_two = template_json(
            2, "template_two", "sms", "template two content", service_id)
        return {'data': [template_one, template_two]}

    mock_class = mocker.patch(
        'app.notifications_api_client.get_service_templates',
        side_effect=_create)
    return mock_class


@pytest.fixture(scope='function')
def mock_delete_service_template(mocker):
    def _delete(service_id, template_id):
        template = template_json(
            template_id, "Template to delete",
            "sms", "content to be deleted", service_id)
        return {'data': template}

    return mocker.patch(
        'app.notifications_api_client.delete_service_template', side_effect=_delete)


@pytest.fixture(scope='function')
def mock_api_user(mocker):
    from app.notify_client.user_api_client import User
    user_data = {'id': 1,
                 'name': 'Test User',
                 'password': 'somepassword',
                 'email_address': 'test@user.gov.uk',
                 'mobile_number': '+441234123412',
                 'state': 'pending'
                 }
    user = User(user_data)
    return user


@pytest.fixture(scope='function')
def mock_register_user(mocker, mock_api_user):
    mock_class = mocker.patch('app.user_api_client.register_user')
    mock_class.return_value = mock_api_user
    return mock_class


@pytest.fixture(scope='function')
def mock_user_loader(mocker, mock_api_user):
    mock_class = mocker.patch('app.main.dao.users_dao.get_user_by_id')
    mock_class.return_value = mock_api_user
    return mock_class


@pytest.fixture(scope='function')
def mock_activate_user(mocker, mock_api_user):
    def _activate(mock_api_user):
        mock_api_user.state = 'active'
        return mock_api_user
    return mocker.patch('app.user_api_client.update_user', side_effect=_activate)


@pytest.fixture(scope='function')
def mock_user_dao_get_user(mocker):
    mock_class = mocker.patch('app.main.dao.users_dao.get_user_by_id')
    mock_class.return_value = mock_api_user
    return mock_class


@pytest.fixture(scope='function')
def mock_user_dao_get_by_email(mocker, mock_api_user):
    mock_class = mocker.patch('app.main.dao.users_dao.get_user_by_email')
    mock_class.return_value = mock_api_user
    return mock_class


@pytest.fixture(scope='function')
def mock_user_dao_update_email(mocker, mock_api_user):
    def _update(id, email_address):
        mock_api_user.fields['email_address'] = email_address
    return mocker.patch('app.main.dao.users_dao.update_email_address', side_effect=_update)


@pytest.fixture(scope='function')
def mock_user_dao_update_mobile(mocker, mock_api_user):
    def _update(id, mobile_number):
        mock_api_user.fields['mobile_number'] = mobile_number
    return mocker.patch('app.main.dao.users_dao.update_mobile_number', side_effect=_update)


@pytest.fixture(scope='function')
def mock_user_dao_password_reset(mocker, mock_api_user):
    def _reset(email):
        mock_api_user.state = 'request_password_reset'
    return mocker.patch('app.main.dao.users_dao.request_password_reset', side_effect=_reset)


@pytest.fixture(scope='function')
def mock_user_dao_get_new_password(mocker, mock_api_user):
    mock_api_user.state = 'request_password_reset'
    mock_class = mocker.patch('app.main.dao.users_dao.get_user_by_email')
    mock_class.return_value = mock_api_user
    return mock_class


@pytest.fixture(scope='function')
def mock_create_api_key(mocker):
    def _create(service_id, key_name):
        import uuid
        return {'data': str(uuid.uuid4())}

    mock_class = mocker.patch('app.api_key_api_client.create_api_key', side_effect=_create)
    return mock_class


@pytest.fixture(scope='function')
def mock_revoke_api_key(mocker):
    def _revoke(service_id, key_id):
        return {}

    mock_class = mocker.patch('app.api_key_api_client.revoke_api_key', side_effect=_revoke)
    return mock_class


@pytest.fixture(scope='function')
def mock_get_api_keys(mocker):
    def _get_keys(service_id, key_id=None):
        keys = {'apiKeys': [api_key_json(1, 'some key name'),
                            api_key_json(2, 'another key name', expiry_date=str(date.fromtimestamp(0)))]}
        return keys

    mock_class = mocker.patch('app.api_key_api_client.get_api_keys', side_effect=_get_keys)
    return mock_class


@pytest.fixture(scope='function')
def mock_get_no_api_keys(mocker):
    def _get_keys(service_id):
        keys = {'apiKeys': []}
        return keys

    mock_class = mocker.patch('app.api_key_api_client.get_api_keys', side_effect=_get_keys)
    return mock_class