mirror of
https://github.com/GSA/notifications-admin.git
synced 2026-02-05 02:42:26 -05:00
a6d19ff45b
By default a service should be active (ie keys not suspended). For some reason the API is returning the opposite. This commit reverses the logic to make it look right for hack day.
369 lines
11 KiB
Python
369 lines
11 KiB
Python
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, mock_api_user):
|
|
return service_json(1, 'service one', [mock_api_user.id])
|
|
|
|
|
|
@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, mock_api_user):
|
|
def _get(service_id):
|
|
service = service_json(
|
|
service_id, "Test Service", [mock_api_user.id], limit=1000,
|
|
active=True, restricted=True)
|
|
return {'data': service, 'token': 1}
|
|
|
|
return mocker.patch('app.notifications_api_client.get_service', side_effect=_get)
|
|
|
|
|
|
@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, mock_active_user):
|
|
def _create(user_id):
|
|
service_one = service_json(
|
|
1, "service_one", [mock_active_user.id], 1000, True, False)
|
|
service_two = service_json(
|
|
2, "service_two", [mock_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, "Two week reminder", "sms", "Your vehicle tax is about to expire", 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': '+4412341234',
|
|
'state': 'pending',
|
|
'failed_login_count': 0
|
|
}
|
|
user = User(user_data)
|
|
return user
|
|
|
|
|
|
@pytest.fixture(scope='function')
|
|
def mock_register_user(mocker, mock_api_user):
|
|
def _register(name, email_address, mobile_number, password):
|
|
mock_api_user.name = name
|
|
mock_api_user.email_address = email_address
|
|
mock_api_user.mobile_number = mobile_number
|
|
mock_api_user.password = password
|
|
return mock_api_user
|
|
|
|
return mocker.patch('app.user_api_client.register_user', side_effect=_register)
|
|
|
|
|
|
@pytest.fixture(scope='function')
|
|
def mock_active_user(mocker, mock_api_user):
|
|
mock_api_user.state = 'active'
|
|
return mock_api_user
|
|
|
|
|
|
@pytest.fixture(scope='function')
|
|
def mock_activate_user(mocker):
|
|
def _activate(user):
|
|
user.state = 'active'
|
|
return user
|
|
|
|
return mocker.patch('app.user_api_client.update_user', side_effect=_activate)
|
|
|
|
|
|
@pytest.fixture(scope='function')
|
|
def mock_get_user(mocker, mock_active_user):
|
|
def _get_user(id):
|
|
return mock_active_user
|
|
|
|
return mocker.patch('app.main.dao.users_dao.get_user_by_id', side_effect=_get_user)
|
|
|
|
|
|
@pytest.fixture(scope='function')
|
|
def mock_get_by_email(mocker, mock_api_user, mock_active_user, mock_get_user):
|
|
def _get_user(email_address):
|
|
if email_address == 'notfound@example.gov.uk':
|
|
return None
|
|
if email_address == 'locked_user@example.gov.uk':
|
|
mock_active_user.failed_login_count = 5
|
|
return mock_active_user
|
|
if email_address == 'inactive_user@example.gov.uk':
|
|
mock_active_user.state = 'inactive'
|
|
if email_address == 'pending_user@example.gov.uk':
|
|
return mock_api_user
|
|
|
|
else:
|
|
mock_active_user.email_address = email_address
|
|
return mock_active_user
|
|
return mocker.patch('app.main.dao.users_dao.get_user_by_email', side_effect=_get_user)
|
|
|
|
|
|
@pytest.fixture(scope='function')
|
|
def mock_user_checkpassword(mocker, mock_active_user):
|
|
def _check(mock_active_user, password):
|
|
return True
|
|
|
|
return mocker.patch('app.main.dao.users_dao.verify_password', side_effect=_check)
|
|
|
|
|
|
@pytest.fixture(scope='function')
|
|
def mock_update_email(mocker, mock_active_user):
|
|
def _update(id, email_address):
|
|
mock_active_user.email_address = email_address
|
|
|
|
return mocker.patch('app.main.dao.users_dao.update_email_address', side_effect=_update)
|
|
|
|
|
|
@pytest.fixture(scope='function')
|
|
def mock_update_mobile(mocker, mock_active_user):
|
|
|
|
def _update(id, mobile_number):
|
|
mock_active_user.mobile_number = mobile_number
|
|
|
|
return mocker.patch('app.main.dao.users_dao.update_mobile_number', side_effect=_update)
|
|
|
|
|
|
@pytest.fixture(scope='function')
|
|
def mock_password_reset(mocker, mock_active_user):
|
|
|
|
def _reset(email):
|
|
mock_active_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_get_user_from_api(mocker, mock_active_user):
|
|
def _get_user(email_address):
|
|
return mock_active_user
|
|
return mocker.patch('app.main.dao.users_dao.user_api_client.get_user_by_email', side_effect=_get_user)
|
|
|
|
|
|
@pytest.fixture(scope='function')
|
|
def mock_get_all_users_from_api(mocker):
|
|
return mocker.patch('app.main.dao.users_dao.user_api_client.get_users')
|
|
|
|
|
|
@pytest.fixture(scope='function')
|
|
def mock_update_user_email_api(mocker):
|
|
def _update(user):
|
|
return user
|
|
return mocker.patch('app.main.dao.users_dao.user_api_client.update_user', side_effect=_update)
|
|
|
|
|
|
@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
|