darkhelm/notifications-admin
1
0
Fork 0
mirror of https://github.com/GSA/notifications-admin.git synced 2026-07-25 18:38:57 -04:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into platform-admin

Browse Source 
Conflicts:
	app/__init__.py
	app/main/views/add_service.py
	app/main/views/jobs.py
	app/templates/main_nav.html
	tests/app/main/views/test_dashboard.py
	tests/conftest.py
This commit is contained in:
Rebecca Law
2016-03-18 16:32:10 +00:00
parent 13d9acf7dd ef1ec2c9a1
commit 402f55be23
66 changed files with 1356 additions and 597 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
tests/__init__.py
View File

@@ -31,7 +31,7 @@ def service_json(id_, name, users, limit=1000, active=False, restricted=True):
}
def template_json(id_, name, type_, content, service_id):
def template_json(service_id, id_=1, name="sample template", type_="sms", content="template content"):
return {
'id': id_,
'name': name,
@@ -116,13 +116,40 @@ def job_json():
return data
def notification_json():
def notification_json(service_id,
job=None,
template=None,
to='07123456789',
status='sent',
sent_at=None,
created_at=None,
with_links=False):
import datetime
if job is None:
job = job_json()
if template is None:
template = template_json(service_id)
if sent_at is None:
sent_at = str(datetime.datetime.now().time())
if created_at is None:
created_at = str(datetime.datetime.now().time())
links = {}
if with_links:
links = {
'prev': '/service/{}/notifications'.format(service_id),
'next': '/service/{}/notifications'.format(service_id),
'last': '/service/{}/notifications'.format(service_id)
}
data = {
'notifications': [{
'sent_at': str(datetime.datetime.now().time())
'to': to,
'template': {'id': template['id'], 'name': template['name']},
'job': {'id': job['id'], 'original_file_name': job['original_file_name']},
'sent_at': sent_at,
'status': status,
'created_at': created_at
} for i in range(5)],
'links': {}
'links': links
}
return data

13
tests/app/main/notify_client/test_statistics_client.py Normal file
View File

@@ -0,0 +1,13 @@
from app.notify_client.statistics_api_client import StatisticsApiClient
def test_client_uses_correct_find_by_email(mocker, api_user_active):
expected_url = '/service/a1b2c3d4/notifications-statistics'
client = StatisticsApiClient()
mock_get = mocker.patch('app.notify_client.statistics_api_client.StatisticsApiClient.get')
client.get_statistics_for_service('a1b2c3d4')
mock_get.assert_called_once_with(url=expected_url)

91
tests/app/main/test_verify_form.py
View File

@@ -1,91 +0,0 @@
from datetime import datetime, timedelta
from app.main.forms import VerifyForm
from app.main.dao import users_dao
from tests import create_test_user
def test_form_should_have_error_when_code_is_not_valid(app_,
mock_check_verify_code):
with app_.test_request_context(method='POST',
data={'sms_code': '12345aa', 'email_code': 'abcde'}) as req:
def _check_code(code, code_type):
return users_dao.check_verify_code('1', code, code_type)
form = VerifyForm(_check_code)
assert form.validate() is False
errors = form.errors
assert len(errors) == 2
expected = {'email_code': ['Code must be 5 digits', 'Code does not match'],
'sms_code': ['Code does not match', 'Code must be 5 digits']}
assert 'sms_code' in errors
assert set(errors) == set(expected)
def test_should_return_errors_when_code_missing(app_,
mock_check_verify_code):
with app_.test_request_context(method='POST',
data={}) as req:
def _check_code(code, code_type):
return users_dao.check_verify_code('1', code, code_type)
form = VerifyForm(_check_code)
assert form.validate() is False
errors = form.errors
expected = {'sms_code': ['SMS code can not be empty'],
'email_code': ['Email code can not be empty']}
assert len(errors) == 2
assert set(errors) == set(expected)
def test_should_return_errors_when_code_is_too_short(app_,
mock_check_verify_code):
with app_.test_request_context(method='POST',
data={'sms_code': '123', 'email_code': '123'}) as req:
def _check_code(code, code_type):
return users_dao.check_verify_code('1', code, code_type)
form = VerifyForm(_check_code)
assert form.validate() is False
errors = form.errors
expected = {'sms_code': ['Code must be 5 digits', 'Code does not match'],
'email_code': ['Code must be 5 digits', 'Code does not match']}
assert len(errors) == 2
assert set(errors) == set(expected)
def test_should_return_errors_when_code_does_not_match(app_,
mock_check_verify_code_code_not_found):
with app_.test_request_context(method='POST',
data={'sms_code': '34567', 'email_code': '34567'}) as req:
def _check_code(code, code_type):
return users_dao.check_verify_code('1', code, code_type)
form = VerifyForm(_check_code)
assert form.validate() is False
errors = form.errors
expected = {'sms_code': ['Code not found'],
'email_code': ['Code not found']}
assert len(errors) == 2
assert set(errors) == set(expected)
def test_should_return_errors_when_code_is_expired(app_,
mock_check_verify_code_code_expired):
with app_.test_request_context(method='POST',
data={'sms_code': '23456',
'email_code': '23456'}) as req:
def _check_code(code, code_type):
return users_dao.check_verify_code('1', code, code_type)
form = VerifyForm(_check_code)
assert form.validate() is False
errors = form.errors
expected = {'sms_code': ['Code has expired'],
'email_code': ['Code has expired']}
assert len(errors) == 2
assert set(errors) == set(expected)

6
tests/app/main/views/test_accept_invite.py
View File

@@ -175,7 +175,7 @@ def test_new_user_accept_invite_calls_api_and_views_registration_page(app_,
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'Create an account'
email_in_page = page.find('p')
email_in_page = page.find('main').find('p')
assert email_in_page.text.strip() == 'Your account will be created with this email: invited_user@test.gov.uk' # noqa
form = page.find('form')
@@ -215,6 +215,7 @@ def test_new_user_accept_invite_completes_new_registration_redirects_to_verify(a
api_user_active,
mock_check_invite_token,
mock_dont_get_user_by_email,
mock_is_email_unique,
mock_register_user,
mock_send_verify_code,
mock_get_users_by_service,
@@ -266,6 +267,7 @@ def test_new_invited_user_verifies_and_added_to_service(app_,
api_user_active,
mock_check_invite_token,
mock_dont_get_user_by_email,
mock_is_email_unique,
mock_register_user,
mock_send_verify_code,
mock_check_verify_code,
@@ -275,6 +277,7 @@ def test_new_invited_user_verifies_and_added_to_service(app_,
mock_accept_invite,
mock_get_service,
mock_get_service_templates,
mock_get_service_statistics,
mock_get_jobs):
with app_.test_request_context():
@@ -298,6 +301,7 @@ def test_new_invited_user_verifies_and_added_to_service(app_,
# when they post codes back to admin user should be added to
# service and sent on to dash board
expected_permissions = ['send_messages', 'manage_service', 'manage_api_keys']
with client.session_transaction() as session:
new_user_id = session['user_id']
mock_add_user_to_service.assert_called_with(data['service'], new_user_id, expected_permissions)

58
tests/app/main/views/test_code_not_received.py
View File

@@ -1,39 +1,32 @@
import pytest
from flask import url_for
from bs4 import BeautifulSoup
def test_should_render_email_verification_resent_show_email_address_and_resend_verify_email(app_,
mocker,
api_user_active,
mock_get_user_by_email,
mock_send_verify_email):
def test_should_render_email_code_not_received_template_and_populate_email_address(app_,
api_user_active,
mock_get_user_by_email,
mock_send_verify_code):
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_details'] = {
'id': api_user_active.id,
'email': api_user_active.email_address}
response = client.get(url_for('main.check_and_resend_email_code'))
response = client.get(url_for('main.resend_email_verification'))
assert response.status_code == 200
assert 'Check your email address is correct and then resend the confirmation code' \
in response.get_data(as_text=True)
assert 'value="test@user.gov.uk"' in response.get_data(as_text=True)
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
def test_should_check_and_resend_email_code_redirect_to_verify(app_,
api_user_active,
mock_get_user_by_email,
mock_update_user,
mock_send_verify_code):
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_details'] = {
'id': api_user_active.id,
'email': api_user_active.email_address}
response = client.post(url_for('main.check_and_resend_email_code'),
data={'email_address': 'test@user.gov.uk'})
assert response.status_code == 302
assert response.location == url_for('main.verify', _external=True)
assert page.h1.string == 'Check your email'
expected = "In order to verify your email address we've sent a new confirmation link to {}".format(api_user_active.email_address) # noqa
message = page.find_all('p')[1].text
assert message == expected
mock_send_verify_email.assert_called_with(api_user_active.id, api_user_active.email_address)
def test_should_render_text_code_not_received_template(app_,
@@ -70,23 +63,6 @@ def test_should_check_and_redirect_to_verify(app_,
assert response.location == url_for('main.verify', _external=True)
def test_should_update_email_address_resend_code(app_,
api_user_active,
mock_get_user_by_email,
mock_update_user,
mock_send_verify_code):
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_details'] = {
'id': api_user_active.id,
'email': api_user_active.email_address}
response = client.post(url_for('main.check_and_resend_email_code'),
data={'email_address': 'new@address.gov.uk'})
assert response.status_code == 302
assert response.location == url_for('main.verify', _external=True)
def test_should_update_mobile_number_resend_code(app_,
api_user_active,
mock_get_user_by_email,

2
tests/app/main/views/test_dashboard.py
View File

@@ -5,6 +5,7 @@ def test_should_show_recent_jobs_on_dashboard(app_,
api_user_active,
mock_get_service,
mock_get_service_templates,
mock_get_service_statistics,
mock_get_user,
mock_get_user_by_email,
mock_login,
@@ -33,6 +34,7 @@ def _test_dashboard_menu(mocker, app_, usr, service, permissions):
mocker.patch('app.user_api_client.get_user', return_value=usr)
mocker.patch('app.user_api_client.get_user_by_email', return_value=usr)
mocker.patch('app.service_api_client.get_service', return_value={'data': service})
mocker.patch('app.statistics_api_client.get_statistics_for_service', return_value={'data': [{}]})
client.login(usr)
return client.get(url_for('main.service_dashboard', service_id=service['id']))

42
tests/app/main/views/test_jobs.py
View File

@@ -80,3 +80,45 @@ def test_should_show_updates_for_one_job_as_json(
assert 'Recipient' in content['notifications']
assert 'Status' in content['notifications']
assert 'Started' in content['status']
def test_should_show_notifications_for_a_service(app_,
service_one,
api_user_active,
mock_login,
mock_get_user,
mock_get_user_by_email,
mock_get_service,
mock_get_notifications):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.view_notifications', service_id=service_one['id']))
assert response.status_code == 200
content = response.get_data(as_text=True)
notifications = mock_get_notifications(service_one['id'])
notification = notifications['notifications'][0]
assert notification['to'] in content
assert notification['status'] in content
assert notification['template']['name'] in content
assert '.csv' in content
def test_should_show_notifications_for_a_service_with_next_previous(app_,
service_one,
api_user_active,
mock_login,
mock_get_user,
mock_get_user_by_email,
mock_get_service,
mock_get_notifications_with_previous_next):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.view_notifications', service_id=service_one['id'], page=2))
assert response.status_code == 200
content = response.get_data(as_text=True)
assert url_for('main.view_notifications', service_id=service_one['id'], page=3) in content
assert url_for('main.view_notifications', service_id=service_one['id'], page=1) in content
assert 'Previous page' in content
assert 'Next page' in content

54
tests/app/main/views/test_register.py
View File

@@ -1,4 +1,8 @@
from flask import url_for
from flask import (
url_for,
session
)
from bs4 import BeautifulSoup
@@ -24,24 +28,31 @@ def test_logged_in_user_redirects_to_choose_service(app_,
assert response.location == url_for('main.choose_service', _external=True)
def test_process_register_creates_new_user(app_,
mock_send_verify_code,
mock_register_user,
mock_get_user_by_email_not_found,
mock_login):
user_data = {
'name': 'Some One Valid',
'email_address': 'notfound@example.gov.uk',
'mobile_number': '+4407700900460',
'password': 'validPassword!'
}
def test_register_creates_new_user_and_redirects_to_continue_page(app_,
mock_send_verify_code,
mock_register_user,
mock_get_user_by_email_not_found,
mock_is_email_unique,
mock_send_verify_email,
mock_login):
user_data = {'name': 'Some One Valid',
'email_address': 'notfound@example.gov.uk',
'mobile_number': '+4407700900460',
'password': 'validPassword!'
}
with app_.test_request_context():
response = app_.test_client().post(url_for('main.register'),
data=user_data)
response = app_.test_client().post(url_for('main.register'), data=user_data)
assert response.status_code == 302
assert response.location == url_for('main.verify', _external=True)
assert mock_register_user.called
assert response.location == url_for('main.registration_continue', _external=True)
from unittest.mock import ANY
mock_send_verify_email.assert_called_with(ANY, user_data['email_address'])
mock_register_user.assert_called_with(user_data['name'],
user_data['email_address'],
user_data['mobile_number'],
user_data['password'])
def test_process_register_returns_200_when_mobile_number_is_invalid(app_,
@@ -59,7 +70,7 @@ def test_process_register_returns_200_when_mobile_number_is_invalid(app_,
assert 'Must not contain letters or symbols' in response.get_data(as_text=True)
def test_should_return_400_when_email_is_not_gov_uk(app_,
def test_should_return_200_when_email_is_not_gov_uk(app_,
mock_send_verify_code,
mock_get_user_by_email,
mock_login):
@@ -74,11 +85,13 @@ def test_should_return_400_when_email_is_not_gov_uk(app_,
assert 'Enter a gov.uk email address' in response.get_data(as_text=True)
def test_should_add_verify_codes_on_session(app_,
def test_should_add_user_details_to_session(app_,
mock_send_verify_code,
mock_register_user,
mock_get_user,
mock_get_user_by_email_not_found,
mock_is_email_unique,
mock_send_verify_email,
mock_login):
user_data = {
'name': 'Test Codes',
@@ -91,11 +104,12 @@ def test_should_add_verify_codes_on_session(app_,
with app_.test_client() as client:
response = client.post(url_for('main.register'),
data=user_data)
assert response.status_code == 302
assert 'notify_admin_session' in response.headers.get('Set-Cookie')
assert session['user_details']['email'] == user_data['email_address']
def test_should_return_400_if_password_is_blacklisted(app_,
def test_should_return_200_if_password_is_blacklisted(app_,
mock_get_user_by_email,
mock_login):
with app_.test_request_context():

1
tests/app/main/views/test_sign_out.py
View File

@@ -16,6 +16,7 @@ def test_sign_out_user(app_,
mock_get_user,
mock_get_user_by_email,
mock_get_service_templates,
mock_get_service_statistics,
mock_login,
mock_get_jobs,
mock_has_permissions):

160
tests/app/main/views/test_user_profile.py
View File

@@ -2,105 +2,109 @@ import json
from flask import url_for
def test_should_show_overview_page(app_,
api_user_active,
mock_login,
mock_get_user):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.user_profile'))
# def test_should_show_overview_page(app_,
# api_user_active,
# mock_login,
# mock_get_user):
# with app_.test_request_context():
# with app_.test_client() as client:
# client.login(api_user_active)
# response = client.get(url_for('main.user_profile'))
assert 'Your profile' in response.get_data(as_text=True)
assert response.status_code == 200
# assert 'Your profile' in response.get_data(as_text=True)
# assert response.status_code == 200
def test_should_show_name_page(app_,
api_user_active,
mock_login,
mock_get_user):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.user_profile_name'))
# def test_should_show_name_page(app_,
# api_user_active,
# mock_login,
# mock_get_user):
# with app_.test_request_context():
# with app_.test_client() as client:
# client.login(api_user_active)
# response = client.get(url_for('main.user_profile_name'))
assert 'Change your name' in response.get_data(as_text=True)
assert response.status_code == 200
# assert 'Change your name' in response.get_data(as_text=True)
# assert response.status_code == 200
def test_should_redirect_after_name_change(app_,
api_user_active,
mock_login,
mock_update_user,
mock_get_user):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
new_name = 'New Name'
data = {'new_name': new_name}
response = client.post(url_for(
'main.user_profile_name'), data=data)
# def test_should_redirect_after_name_change(app_,
# api_user_active,
# mock_login,
# mock_update_user,
# mock_get_user):
# with app_.test_request_context():
# with app_.test_client() as client:
# client.login(api_user_active)
# new_name = 'New Name'
# data = {'new_name': new_name}
# response = client.post(url_for(
# 'main.user_profile_name'), data=data)
assert response.status_code == 302
assert response.location == url_for(
'main.user_profile', _external=True)
api_user_active.name = new_name
assert mock_update_user.called
# assert response.status_code == 302
# assert response.location == url_for(
# 'main.user_profile', _external=True)
# api_user_active.name = new_name
# assert mock_update_user.called
def test_should_show_email_page(app_,
api_user_active,
mock_login,
mock_get_user):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for(
'main.user_profile_email'))
# def test_should_show_email_page(app_,
# api_user_active,
# mock_login,
# mock_get_user):
# with app_.test_request_context():
# with app_.test_client() as client:
# client.login(api_user_active)
# response = client.get(url_for(
# 'main.user_profile_email'))
assert 'Change your email address' in response.get_data(as_text=True)
assert response.status_code == 200
# assert 'Change your email address' in response.get_data(as_text=True)
# assert response.status_code == 200
def test_should_redirect_after_email_change(app_,
api_user_active,
mock_login,
mock_get_user,
mock_get_user_by_email_not_found):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
data = {'email_address': 'new_notify@notify.gov.uk'}
response = client.post(
url_for('main.user_profile_email'),
data=data)
# def test_should_redirect_after_email_change(app_,
# api_user_active,
# mock_login,
# mock_get_user,
# mock_get_user_by_email_not_found,
# mock_is_email_unique):
# with app_.test_request_context():
# with app_.test_client() as client:
# client.login(api_user_active)
# data = {'email_address': 'new_notify@notify.gov.uk'}
# response = client.post(
# url_for('main.user_profile_email'),
# data=data)
assert response.status_code == 302
assert response.location == url_for(
'main.user_profile_email_authenticate', _external=True)
# assert response.status_code == 302
# assert response.location == url_for(
# 'main.user_profile_email_authenticate', _external=True)
def test_should_show_authenticate_after_email_change(app_,
api_user_active,
mock_login,
mock_get_user,
mock_verify_password):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
with client.session_transaction() as session:
session['new-email'] = 'new_notify@notify.gov.uk'
response = client.get(url_for('main.user_profile_email_authenticate'))
# def test_should_show_authenticate_after_email_change(app_,
# api_user_active,
# mock_login,
# mock_get_user,
# mock_verify_password):
# with app_.test_request_context():
# with app_.test_client() as client:
# client.login(api_user_active)
# with client.session_transaction() as session:
# session['new-email'] = 'new_notify@notify.gov.uk'
# response = client.get(url_for('main.user_profile_email_authenticate'))
assert 'Change your email address' in response.get_data(as_text=True)
assert 'Confirm' in response.get_data(as_text=True)
assert response.status_code == 200
# assert 'Change your email address' in response.get_data(as_text=True)
# assert 'Confirm' in response.get_data(as_text=True)
# assert response.status_code == 200
def test_should_redirect_after_email_change_confirm(app_,
api_user_active,
mock_login,
mock_get_user):
mock_get_user,
mock_verify_password,
mock_send_verify_code,
mock_is_email_unique):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)

64
tests/app/main/views/test_verify.py
View File

@@ -1,5 +1,7 @@
from flask import url_for
from bs4 import BeautifulSoup
def test_should_return_verify_template(app_,
api_user_active,
@@ -12,26 +14,29 @@ def test_should_return_verify_template(app_,
session['user_details'] = {'email_address': api_user_active.email_address, 'id': api_user_active.id}
response = client.get(url_for('main.verify'))
assert response.status_code == 200
assert (
"We’ve sent you confirmation codes by email and text message."
) in response.get_data(as_text=True)
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.text == 'Text verification'
message = page.find_all('p')[1].text
assert message == "We've sent you a text message with a verification code."
def test_should_redirect_to_add_service_when_code_are_correct(app_,
api_user_active,
mock_get_user,
mock_update_user,
mock_check_verify_code):
def test_should_redirect_to_add_service_when_sms_code_is_correct(app_,
api_user_active,
mock_get_user,
mock_update_user,
mock_check_verify_code):
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_details'] = {'email_address': api_user_active.email_address, 'id': api_user_active.id}
response = client.post(url_for('main.verify'),
data={'sms_code': '12345',
'email_code': '23456'})
data={'sms_code': '12345'})
assert response.status_code == 302
assert response.location == url_for('main.add_service', first='first', _external=True)
mock_check_verify_code.assert_called_once_with(api_user_active.id, '12345', 'sms')
def test_should_activate_user_after_verify(app_,
api_user_active,
@@ -44,45 +49,20 @@ def test_should_activate_user_after_verify(app_,
with client.session_transaction() as session:
session['user_details'] = {'email_address': api_user_active.email_address, 'id': api_user_active.id}
client.post(url_for('main.verify'),
data={'sms_code': '12345',
'email_code': '23456'})
data={'sms_code': '12345'})
assert mock_update_user.called
def test_should_return_200_when_codes_are_wrong(app_,
api_user_active,
mock_get_user,
mock_check_verify_code_code_not_found):
def test_should_return_200_when_sms_code_is_wrong(app_,
api_user_active,
mock_get_user,
mock_check_verify_code_code_not_found):
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_details'] = {'email_address': api_user_active.email_address, 'id': api_user_active.id}
response = client.post(url_for('main.verify'),
data={'sms_code': '12345',
'email_code': '23456'})
data={'sms_code': '12345'})
assert response.status_code == 200
resp_data = response.get_data(as_text=True)
assert resp_data.count('Code not found') == 2
def test_should_only_check_codes_in_validation_if_both_are_present(app_,
api_user_active,
mock_get_user,
mock_update_user,
mock_check_verify_code):
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_details'] = {'email_address': api_user_active.email_address, 'id': api_user_active.id}
response = client.post(url_for('main.verify'), data={'sms_code': '12345'})
assert response.status_code == 200
assert not mock_check_verify_code.called
response = client.post(url_for('main.verify'), data={'email_code': '12345'})
assert response.status_code == 200
assert not mock_check_verify_code.called
response = client.post(url_for('main.verify'), data={'sms_code': '12345', 'email_code': '12345'})
assert response.status_code == 302
assert mock_check_verify_code.called
assert mock_check_verify_code.call_count == 2
assert resp_data.count('Code not found') == 1

79
tests/conftest.py
View File

@@ -2,7 +2,9 @@ import uuid
from datetime import date, datetime, timedelta
from unittest.mock import Mock
import pytest
from app import create_app
from . import (
service_json,
TestClient,
@@ -16,12 +18,13 @@ from app.notify_client.models import (
User,
InvitedUser
)
from notifications_python_client.errors import HTTPError
@pytest.fixture(scope='session')
def app_(request):
app = create_app('test')
app = create_app()
ctx = app.app_context()
ctx.push()
@@ -144,11 +147,20 @@ def mock_delete_service(mocker, mock_get_service):
'app.service_api_client.delete_service', side_effect=_delete)
@pytest.fixture(scope='function')
def mock_get_service_statistics(mocker):
def _create(service_id):
return {'data': [{}]}
return mocker.patch(
'app.statistics_api_client.get_statistics_for_service', side_effect=_create)
@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)
service_id, template_id, "Two week reminder", "sms", "Your vehicle tax is about to expire")
return {'data': template}
return mocker.patch(
@@ -159,7 +171,7 @@ def mock_get_service_template(mocker):
def mock_get_service_email_template(mocker):
def _create(service_id, template_id):
template = template_json(
template_id, "Two week reminder", "email", "Your vehicle tax is about to expire", service_id)
service_id, template_id, "Two week reminder", "email", "Your vehicle tax is about to expire")
return {'data': template}
return mocker.patch(
@@ -195,16 +207,16 @@ def mock_get_service_templates(mocker):
def _create(service_id):
return {'data': [
template_json(
1, "sms_template_one", "sms", "sms template one content", service_id
service_id, 1, "sms_template_one", "sms", "sms template one content"
),
template_json(
2, "sms_template_two", "sms", "sms template two content", service_id
service_id, 2, "sms_template_two", "sms", "sms template two content"
),
template_json(
3, "email_template_one", "email", "email template one content", service_id
service_id, 3, "email_template_one", "email", "email template one content"
),
template_json(
4, "email_template_two", "email", "email template two content", service_id
service_id, 4, "email_template_two", "email", "email template two content"
)
]}
@@ -217,8 +229,7 @@ def mock_get_service_templates(mocker):
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)
service_id, template_id, "Template to delete", "sms", "content to be deleted")
return {'data': template}
return mocker.patch(
@@ -366,7 +377,6 @@ def mock_get_user(mocker, api_user_active):
def _get_user(id):
api_user_active.id = id
return api_user_active
return mocker.patch(
'app.user_api_client.get_user', side_effect=_get_user)
@@ -385,10 +395,10 @@ def mock_get_user_pending(mocker, api_user_pending):
@pytest.fixture(scope='function')
def mock_get_user_by_email(mocker, api_user_active):
def _get_user(email_address):
api_user_active._email_address = email_address
return api_user_active
return mocker.patch('app.user_api_client.get_user_by_email', side_effect=_get_user)
@@ -397,16 +407,15 @@ def mock_get_user_with_permissions(mocker, api_user_active):
def _get_user(id):
api_user_active._permissions[''] = ['manage_users', 'manage_templates', 'manage_settings']
return api_user_active
return mocker.patch(
'app.user_api_client.get_user', side_effect=_get_user)
@pytest.fixture(scope='function')
def mock_dont_get_user_by_email(mocker):
def _get_user(email_address):
return None
return mocker.patch(
'app.user_api_client.get_user_by_email',
side_effect=_get_user,
@@ -455,7 +464,6 @@ def mock_get_user_by_email_not_found(mocker):
def mock_verify_password(mocker):
def _verify_password(user, password):
return True
return mocker.patch(
'app.user_api_client.verify_password',
side_effect=_verify_password)
@@ -463,15 +471,20 @@ def mock_verify_password(mocker):
@pytest.fixture(scope='function')
def mock_update_user(mocker):
def _update(user):
return user
return mocker.patch('app.user_api_client.update_user', side_effect=_update)
@pytest.fixture(scope='function')
def mock_is_email_unique(mocker):
return mocker.patch('app.user_api_client.get_user_by_email', return_value=None)
return mocker.patch('app.user_api_client.is_email_unique', return_value=True)
@pytest.fixture(scope='function')
def mock_is_email_not_unique(mocker):
return mocker.patch('app.user_api_client.is_email_unique', return_value=False)
@pytest.fixture(scope='function')
@@ -481,6 +494,7 @@ def mock_get_all_users_from_api(mocker):
@pytest.fixture(scope='function')
def mock_create_api_key(mocker):
def _create(service_id, key_name):
import uuid
return {'data': str(uuid.uuid4())}
@@ -542,11 +556,15 @@ def mock_send_verify_code(mocker):
return mocker.patch('app.user_api_client.send_verify_code')
@pytest.fixture(scope='function')
def mock_send_verify_email(mocker):
return mocker.patch('app.user_api_client.send_verify_email')
@pytest.fixture(scope='function')
def mock_check_verify_code(mocker):
def _verify(user_id, code, code_type):
return True, ''
return mocker.patch(
'app.user_api_client.check_verify_code',
side_effect=_verify)
@@ -556,7 +574,6 @@ def mock_check_verify_code(mocker):
def mock_check_verify_code_code_not_found(mocker):
def _verify(user_id, code, code_type):
return False, 'Code not found'
return mocker.patch(
'app.user_api_client.check_verify_code',
side_effect=_verify)
@@ -566,7 +583,6 @@ def mock_check_verify_code_code_not_found(mocker):
def mock_check_verify_code_code_expired(mocker):
def _verify(user_id, code, code_type):
return False, 'Code has expired'
return mocker.patch(
'app.user_api_client.check_verify_code',
side_effect=_verify)
@@ -588,7 +604,6 @@ def mock_create_job(mocker, job_data):
job_data['file_name'] = '{}.csv'.format(job_id)
job_data['notification_count'] = notification_count
return job_data
return mocker.patch('app.job_api_client.create_job', side_effect=_create)
@@ -598,7 +613,6 @@ def mock_get_job(mocker, job_data):
job_data['id'] = job_id
job_data['service'] = service_id
return {"data": job_data}
return mocker.patch('app.job_api_client.get_job', side_effect=_get_job)
@@ -613,15 +627,23 @@ def mock_get_jobs(mocker):
job_data['service'] = service_id
data.append(job_data)
return {"data": data}
return mocker.patch('app.job_api_client.get_job', side_effect=_get_jobs)
@pytest.fixture(scope='function')
def mock_get_notifications(mocker):
def _get_notifications(service_id, job_id):
return notification_json()
def _get_notifications(service_id, job_id=None, page=1):
return notification_json(service_id)
return mocker.patch(
'app.notification_api_client.get_notifications_for_service',
side_effect=_get_notifications
)
@pytest.fixture(scope='function')
def mock_get_notifications_with_previous_next(mocker):
def _get_notifications(service_id, job_id=None, page=1):
return notification_json(service_id, with_links=True)
return mocker.patch(
'app.notification_api_client.get_notifications_for_service',
side_effect=_get_notifications
@@ -632,7 +654,6 @@ def mock_get_notifications(mocker):
def mock_has_permissions(mocker):
def _has_permission(permissions=None, or_=False, admin_override=False):
return True
return mocker.patch(
'app.notify_client.user_api_client.User.has_permissions',
side_effect=_has_permission)
@@ -658,7 +679,6 @@ def mock_get_users_by_service(mocker):
'email_address': 'notify@digital.cabinet-office.gov.uk',
'failed_login_count': 0}]
return [User(data[0])]
return mocker.patch('app.user_api_client.get_users_for_service', side_effect=_get_users_for_service, autospec=True)
@@ -666,7 +686,6 @@ def mock_get_users_by_service(mocker):
def mock_s3_upload(mocker):
def _upload(upload_id, service_id, filedata, region):
pass
return mocker.patch('app.main.views.send.s3upload', side_effect=_upload)
@@ -689,6 +708,7 @@ def sample_invited_user(mocker, sample_invite):
@pytest.fixture(scope='function')
def mock_create_invite(mocker, sample_invite):
def _create_invite(from_user, service_id, email_address, permissions):
sample_invite['from_user'] = from_user
sample_invite['service'] = service_id
@@ -696,7 +716,6 @@ def mock_create_invite(mocker, sample_invite):
sample_invite['status'] = 'pending'
sample_invite['permissions'] = permissions
return InvitedUser(**sample_invite)
return mocker.patch('app.invite_api_client.create_invite', side_effect=_create_invite)
@@ -711,7 +730,6 @@ def mock_get_invites_for_service(mocker, service_one, sample_invite):
invite['email_address'] = 'user_{}@testnotify.gov.uk'.format(i)
data.append(InvitedUser(**invite))
return data
return mocker.patch('app.invite_api_client.get_invites_for_service', side_effect=_get_invites)
@@ -719,7 +737,6 @@ def mock_get_invites_for_service(mocker, service_one, sample_invite):
def mock_check_invite_token(mocker, sample_invite):
def _check_token(token):
return InvitedUser(**sample_invite)
return mocker.patch('app.invite_api_client.check_token', side_effect=_check_token)
@@ -727,7 +744,6 @@ def mock_check_invite_token(mocker, sample_invite):
def mock_accept_invite(mocker, sample_invite):
def _accept(service_id, invite_id):
return InvitedUser(**sample_invite)
return mocker.patch('app.invite_api_client.accept_invite', side_effect=_accept)
@@ -735,7 +751,6 @@ def mock_accept_invite(mocker, sample_invite):
def mock_add_user_to_service(mocker, service_one, api_user_active):
def _add_user(service_id, user_id, permissions):
return api_user_active
return mocker.patch('app.user_api_client.add_user_to_service', side_effect=_add_user)