darkhelm/notifications-admin
1
0
Fork 0
mirror of https://github.com/GSA/notifications-admin.git synced 2026-08-24 08:16:51 -04:00
Code Issues Packages Projects Releases Wiki Activity

Use client and logged_in_client fixtures

Browse Source 
Wherever possible, because Don’t Repeat Yourself.
This commit is contained in:
Chris Hill-Scott
2017-02-03 12:07:21 +00:00
parent 929dc45224
commit f3b0c0a556
32 changed files with 2389 additions and 2897 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
tests/app/main/test_add_service_form.py
View File

@@ -2,11 +2,10 @@ from app.main.forms import AddServiceForm
from werkzeug.datastructures import MultiDict
def test_form_should_have_errors_when_duplicate_service_is_added(app_):
def test_form_should_have_errors_when_duplicate_service_is_added(client):
def _get_form_names():
return ['some.service', 'more.names']
with app_.test_request_context():
form = AddServiceForm(_get_form_names,
formdata=MultiDict([('name', 'some service')]))
form.validate()
assert {'name': ['This service name is already in use']} == form.errors
form = AddServiceForm(_get_form_names,
formdata=MultiDict([('name', 'some service')]))
form.validate()
assert {'name': ['This service name is already in use']} == form.errors

6
tests/app/main/test_choose_time_form.py
View File

@@ -5,7 +5,7 @@ from freezegun import freeze_time
@freeze_time("2016-01-01 11:09:00.061258")
def test_form_contains_next_24h(app_):
def test_form_contains_next_24h():
choices = ChooseTimeForm().scheduled_for.choices
@@ -34,12 +34,12 @@ def test_form_contains_next_24h(app_):
@freeze_time("2016-01-01 11:09:00.061258")
def test_form_defaults_to_now(app_):
def test_form_defaults_to_now():
assert ChooseTimeForm().scheduled_for.data == ''
@freeze_time("2016-01-01 11:09:00.061258")
def test_form_contains_next_three_days(app_):
def test_form_contains_next_three_days():
assert ChooseTimeForm().scheduled_for.categories == [
'Later today', 'Tomorrow', 'Sunday', 'Monday'
]

28
tests/app/main/test_create_api_key_form.py
View File

@@ -5,16 +5,15 @@ from werkzeug.datastructures import MultiDict
from app.main.forms import CreateKeyForm
def test_return_validation_error_when_key_name_exists(app_):
def test_return_validation_error_when_key_name_exists(client):
def _get_names():
return ['some key', 'another key']
with app_.test_request_context():
form = CreateKeyForm(_get_names(),
formdata=MultiDict([('key_name', 'Some key')]))
form.key_type.choices = [('a', 'a'), ('b', 'b')]
form.validate()
assert form.errors['key_name'] == ['A key with this name already exists']
form = CreateKeyForm(_get_names(),
formdata=MultiDict([('key_name', 'Some key')]))
form.key_type.choices = [('a', 'a'), ('b', 'b')]
form.validate()
assert form.errors['key_name'] == ['A key with this name already exists']
@pytest.mark.parametrize(
@@ -23,12 +22,11 @@ def test_return_validation_error_when_key_name_exists(app_):
('invalid', 'Not a valid choice')
]
)
def test_return_validation_error_when_key_type_not_chosen(app_, key_type, expected_error):
def test_return_validation_error_when_key_type_not_chosen(client, key_type, expected_error):
with app_.test_request_context():
form = CreateKeyForm(
[],
formdata=MultiDict([('key_name', 'Some key'), ('key_type', key_type)]))
form.key_type.choices = [('a', 'a'), ('b', 'b')]
form.validate()
assert form.errors['key_type'] == [expected_error]
form = CreateKeyForm(
[],
formdata=MultiDict([('key_name', 'Some key'), ('key_type', key_type)]))
form.key_type.choices = [('a', 'a'), ('b', 'b')]
form.validate()
assert form.errors['key_type'] == [expected_error]

11
tests/app/main/test_errorhandlers.py
View File

@@ -2,9 +2,8 @@ from bs4 import BeautifulSoup
from flask import url_for
def test_bad_url_returns_page_not_found(app_):
with app_.test_client() as client:
response = client.get('/bad_url')
assert response.status_code == 404
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'Page could not be found'
def test_bad_url_returns_page_not_found(client):
response = client.get('/bad_url')
assert response.status_code == 404
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'Page could not be found'

64
tests/app/main/test_permissions.py
View File

@@ -6,7 +6,7 @@ from flask import request
def _test_permissions(
app_,
client,
usr,
permissions,
service_id,
@@ -14,31 +14,29 @@ def _test_permissions(
any_=False,
admin_override=False,
):
with app_.test_request_context() as ctx:
request.view_args.update({'service_id': service_id})
with app_.test_client() as client:
if usr:
client.login(usr)
decorator = user_has_permissions(*permissions, any_=any_, admin_override=admin_override)
decorated_index = decorator(index)
if will_succeed:
response = decorated_index()
else:
try:
response = decorated_index()
pytest.fail("Failed to throw a forbidden or unauthorised exception")
except (Forbidden, Unauthorized):
pass
request.view_args.update({'service_id': service_id})
if usr:
client.login(usr)
decorator = user_has_permissions(*permissions, any_=any_, admin_override=admin_override)
decorated_index = decorator(index)
if will_succeed:
response = decorated_index()
else:
try:
response = decorated_index()
pytest.fail("Failed to throw a forbidden or unauthorised exception")
except (Forbidden, Unauthorized):
pass
def test_user_has_permissions_on_endpoint_fail(
app_,
client,
mocker,
):
user = _user_with_permissions()
mocker.patch('app.user_api_client.get_user', return_value=user)
_test_permissions(
app_,
client,
user,
['something'],
'',
@@ -46,13 +44,13 @@ def test_user_has_permissions_on_endpoint_fail(
def test_user_has_permissions_success(
app_,
client,
mocker,
):
user = _user_with_permissions()
mocker.patch('app.user_api_client.get_user', return_value=user)
_test_permissions(
app_,
client,
user,
['manage_users'],
'',
@@ -60,13 +58,13 @@ def test_user_has_permissions_success(
def test_user_has_permissions_or(
app_,
client,
mocker,
):
user = _user_with_permissions()
mocker.patch('app.user_api_client.get_user', return_value=user)
_test_permissions(
app_,
client,
user,
['something', 'manage_users'],
'',
@@ -75,13 +73,13 @@ def test_user_has_permissions_or(
def test_user_has_permissions_multiple(
app_,
client,
mocker,
):
user = _user_with_permissions()
mocker.patch('app.user_api_client.get_user', return_value=user)
_test_permissions(
app_,
client,
user,
['manage_templates', 'manage_users'],
'',
@@ -89,13 +87,13 @@ def test_user_has_permissions_multiple(
def test_exact_permissions(
app_,
client,
mocker,
):
user = _user_with_permissions()
mocker.patch('app.user_api_client.get_user', return_value=user)
_test_permissions(
app_,
client,
user,
['manage_users', 'manage_templates', 'manage_settings'],
'',
@@ -103,13 +101,13 @@ def test_exact_permissions(
def test_platform_admin_user_can_access_page(
app_,
client,
platform_admin_user,
mocker,
):
mocker.patch('app.user_api_client.get_user', return_value=platform_admin_user)
_test_permissions(
app_,
client,
platform_admin_user,
[],
'',
@@ -118,13 +116,13 @@ def test_platform_admin_user_can_access_page(
def test_platform_admin_user_can_not_access_page(
app_,
client,
platform_admin_user,
mocker,
):
mocker.patch('app.user_api_client.get_user', return_value=platform_admin_user)
_test_permissions(
app_,
client,
platform_admin_user,
[],
'',
@@ -133,12 +131,12 @@ def test_platform_admin_user_can_not_access_page(
def test_no_user_returns_401_unauth(
app_
client
):
from flask_login import current_user
assert not current_user
assert not current_user.is_authenticated
_test_permissions(
app_,
client,
None,
[],
'',

126
tests/app/main/test_validators.py
View File

@@ -9,60 +9,56 @@ from unittest.mock import Mock
'govuknotify', '11111111', 'kittykat', 'evangeli'
])
def test_should_raise_validation_error_for_password(
app_,
client,
mock_get_user_by_email,
password,
):
with app_.test_request_context():
form = RegisterUserForm()
form.name.data = 'test'
form.email_address.data = 'teset@example.gov.uk'
form.mobile_number.data = '441231231231'
form.password.data = password
form = RegisterUserForm()
form.name.data = 'test'
form.email_address.data = 'teset@example.gov.uk'
form.mobile_number.data = '441231231231'
form.password.data = password
form.validate()
assert 'Choose a password that’s harder to guess' in form.errors['password']
form.validate()
assert 'Choose a password that’s harder to guess' in form.errors['password']
def test_valid_email_not_in_valid_domains(
app_
client
):
with app_.test_request_context():
form = RegisterUserForm(email_address="test@test.com", mobile_number='441231231231')
assert not form.validate()
assert "Enter a central government email address" in form.errors['email_address'][0]
form = RegisterUserForm(email_address="test@test.com", mobile_number='441231231231')
assert not form.validate()
assert "Enter a central government email address" in form.errors['email_address'][0]
def test_valid_email_in_valid_domains(
app_
client
):
with app_.test_request_context():
form = RegisterUserForm(
name="test",
email_address="test@my.gov.uk",
mobile_number='4407888999111',
password='an uncommon password')
form.validate()
assert form.errors == {}
form = RegisterUserForm(
name="test",
email_address="test@my.gov.uk",
mobile_number='4407888999111',
password='an uncommon password')
form.validate()
assert form.errors == {}
def test_invalid_email_address_error_message(
app_
client
):
with app_.test_request_context():
form = RegisterUserForm(
name="test",
email_address="test.com",
mobile_number='4407888999111',
password='1234567890')
assert not form.validate()
form = RegisterUserForm(
name="test",
email_address="test.com",
mobile_number='4407888999111',
password='1234567890')
assert not form.validate()
form = RegisterUserForm(
name="test",
email_address="test.com",
mobile_number='4407888999111',
password='1234567890')
assert not form.validate()
form = RegisterUserForm(
name="test",
email_address="test.com",
mobile_number='4407888999111',
password='1234567890')
assert not form.validate()
def _gen_mock_field(x):
@@ -94,12 +90,11 @@ def _gen_mock_field(x):
'test@hmcts.net',
])
def test_valid_list_of_white_list_email_domains(
app_,
client,
email,
):
with app_.test_request_context():
email_domain_validators = ValidGovEmail()
email_domain_validators(None, _gen_mock_field(email))
email_domain_validators = ValidGovEmail()
email_domain_validators(None, _gen_mock_field(email))
@pytest.mark.parametrize("email", [
@@ -129,44 +124,41 @@ def test_valid_list_of_white_list_email_domains(
'test@ucds.com'
])
def test_invalid_list_of_white_list_email_domains(
app_,
client,
email,
):
with app_.test_request_context():
email_domain_validators = ValidGovEmail()
with pytest.raises(ValidationError):
email_domain_validators(None, _gen_mock_field(email))
email_domain_validators = ValidGovEmail()
with pytest.raises(ValidationError):
email_domain_validators(None, _gen_mock_field(email))
def test_for_commas_in_placeholders(
app_
client
):
with app_.test_request_context():
with pytest.raises(ValidationError) as error:
NoCommasInPlaceHolders()(None, _gen_mock_field('Hello ((name,date))'))
assert str(error.value) == 'You can’t have commas in your fields'
NoCommasInPlaceHolders()(None, _gen_mock_field('Hello ((name))'))
with pytest.raises(ValidationError) as error:
NoCommasInPlaceHolders()(None, _gen_mock_field('Hello ((name,date))'))
assert str(error.value) == 'You can’t have commas in your fields'
NoCommasInPlaceHolders()(None, _gen_mock_field('Hello ((name))'))
def test_sms_sender_form_validation(
app_,
client,
mock_get_user_by_email,
):
with app_.test_request_context():
form = ServiceSmsSender()
form = ServiceSmsSender()
form.sms_sender.data = 'elevenchars'
form.validate()
assert not form.errors
form.sms_sender.data = 'elevenchars'
form.validate()
assert not form.errors
form.sms_sender.data = ''
form.validate()
assert not form.errors
form.sms_sender.data = ''
form.validate()
assert not form.errors
form.sms_sender.data = 'morethanelevenchars'
form.validate()
assert "Enter fewer than 11 characters" == form.errors['sms_sender'][0]
form.sms_sender.data = 'morethanelevenchars'
form.validate()
assert "Enter fewer than 11 characters" == form.errors['sms_sender'][0]
form.sms_sender.data = '###########'
form.validate()
assert 'Use letters and numbers only' == form.errors['sms_sender'][0]
form.sms_sender.data = '###########'
form.validate()
assert 'Use letters and numbers only' == form.errors['sms_sender'][0]

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

@@ -10,7 +10,7 @@ from tests.conftest import mock_check_invite_token as mock_check_token_invite
def test_existing_user_accept_invite_calls_api_and_redirects_to_dashboard(
app_,
client,
service_one,
api_user_active,
sample_invite,
@@ -26,22 +26,19 @@ def test_existing_user_accept_invite_calls_api_and_redirects_to_dashboard(
expected_redirect_location = 'http://localhost/services/{}/dashboard'.format(expected_service)
expected_permissions = ['send_messages', 'manage_service', 'manage_api_keys']
with app_.test_request_context():
with app_.test_client() as client:
response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'))
response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'))
mock_check_invite_token.assert_called_with('thisisnotarealtoken')
mock_get_user_by_email.assert_called_with('invited_user@test.gov.uk')
assert mock_accept_invite.call_count == 1
mock_add_user_to_service.assert_called_with(expected_service, api_user_active.id, expected_permissions)
mock_check_invite_token.assert_called_with('thisisnotarealtoken')
mock_get_user_by_email.assert_called_with('invited_user@test.gov.uk')
assert mock_accept_invite.call_count == 1
mock_add_user_to_service.assert_called_with(expected_service, api_user_active.id, expected_permissions)
assert response.status_code == 302
assert response.location == expected_redirect_location
assert response.status_code == 302
assert response.location == expected_redirect_location
def test_existing_user_with_no_permissions_accept_invite(
app_,
client,
mocker,
service_one,
api_user_active,
@@ -58,17 +55,14 @@ def test_existing_user_with_no_permissions_accept_invite(
expected_permissions = []
mocker.patch('app.invite_api_client.accept_invite', return_value=sample_invite)
with app_.test_request_context():
with app_.test_client() as client:
response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'))
mock_add_user_to_service.assert_called_with(expected_service, api_user_active.id, expected_permissions)
response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'))
mock_add_user_to_service.assert_called_with(expected_service, api_user_active.id, expected_permissions)
assert response.status_code == 302
assert response.status_code == 302
def test_if_existing_user_accepts_twice_they_redirect_to_sign_in(
app_,
client,
mocker,
sample_invite,
mock_get_service,
@@ -78,19 +72,17 @@ def test_if_existing_user_accepts_twice_they_redirect_to_sign_in(
invite = InvitedUser(**sample_invite)
mocker.patch('app.invite_api_client.check_token', return_value=invite)
with app_.test_request_context():
with app_.test_client() as client:
response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'), follow_redirects=True)
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'Sign in'
flash_banners = page.find_all('div', class_='banner-default')
assert len(flash_banners) == 1
assert flash_banners[0].text.strip() == 'Please log in to access this page.'
response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'), follow_redirects=True)
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'Sign in'
flash_banners = page.find_all('div', class_='banner-default')
assert len(flash_banners) == 1
assert flash_banners[0].text.strip() == 'Please log in to access this page.'
def test_existing_user_of_service_get_redirected_to_signin(
app_,
client,
mocker,
api_user_active,
sample_invite,
@@ -103,20 +95,18 @@ def test_existing_user_of_service_get_redirected_to_signin(
mocker.patch('app.invite_api_client.check_token', return_value=invite)
mocker.patch('app.user_api_client.get_users_for_service', return_value=[api_user_active])
with app_.test_request_context():
with app_.test_client() as client:
response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'), follow_redirects=True)
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'Sign in'
flash_banners = page.find_all('div', class_='banner-default')
assert len(flash_banners) == 1
assert flash_banners[0].text.strip() == 'Please log in to access this page.'
assert mock_accept_invite.call_count == 1
response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'), follow_redirects=True)
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'Sign in'
flash_banners = page.find_all('div', class_='banner-default')
assert len(flash_banners) == 1
assert flash_banners[0].text.strip() == 'Please log in to access this page.'
assert mock_accept_invite.call_count == 1
def test_existing_signed_out_user_accept_invite_redirects_to_sign_in(
app_,
client,
service_one,
api_user_active,
sample_invite,
@@ -130,26 +120,24 @@ def test_existing_signed_out_user_accept_invite_redirects_to_sign_in(
expected_service = service_one['id']
expected_permissions = ['send_messages', 'manage_service', 'manage_api_keys']
with app_.test_request_context():
with app_.test_client() as client:
response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'), follow_redirects=True)
response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'), follow_redirects=True)
mock_check_invite_token.assert_called_with('thisisnotarealtoken')
mock_get_user_by_email.assert_called_with('invited_user@test.gov.uk')
mock_add_user_to_service.assert_called_with(expected_service, api_user_active.id, expected_permissions)
assert mock_accept_invite.call_count == 1
mock_check_invite_token.assert_called_with('thisisnotarealtoken')
mock_get_user_by_email.assert_called_with('invited_user@test.gov.uk')
mock_add_user_to_service.assert_called_with(expected_service, api_user_active.id, expected_permissions)
assert mock_accept_invite.call_count == 1
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'Sign in'
flash_banners = page.find_all('div', class_='banner-default')
assert len(flash_banners) == 1
assert flash_banners[0].text.strip() == 'Please log in to access this page.'
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'Sign in'
flash_banners = page.find_all('div', class_='banner-default')
assert len(flash_banners) == 1
assert flash_banners[0].text.strip() == 'Please log in to access this page.'
def test_new_user_accept_invite_calls_api_and_redirects_to_registration(
app_,
client,
service_one,
mock_check_invite_token,
mock_dont_get_user_by_email,
@@ -160,20 +148,17 @@ def test_new_user_accept_invite_calls_api_and_redirects_to_registration(
expected_redirect_location = 'http://localhost/register-from-invite'
with app_.test_request_context():
with app_.test_client() as client:
response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'))
response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'))
mock_check_invite_token.assert_called_with('thisisnotarealtoken')
mock_dont_get_user_by_email.assert_called_with('invited_user@test.gov.uk')
mock_check_invite_token.assert_called_with('thisisnotarealtoken')
mock_dont_get_user_by_email.assert_called_with('invited_user@test.gov.uk')
assert response.status_code == 302
assert response.location == expected_redirect_location
assert response.status_code == 302
assert response.location == expected_redirect_location
def test_new_user_accept_invite_calls_api_and_views_registration_page(
app_,
client,
service_one,
mock_check_invite_token,
mock_dont_get_user_by_email,
@@ -182,56 +167,51 @@ def test_new_user_accept_invite_calls_api_and_views_registration_page(
mock_get_service,
):
with app_.test_request_context():
with app_.test_client() as client:
response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'), follow_redirects=True)
response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'), follow_redirects=True)
mock_check_invite_token.assert_called_with('thisisnotarealtoken')
mock_dont_get_user_by_email.assert_called_with('invited_user@test.gov.uk')
mock_check_invite_token.assert_called_with('thisisnotarealtoken')
mock_dont_get_user_by_email.assert_called_with('invited_user@test.gov.uk')
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'Create an account'
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'Create an account'
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
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')
name = form.find('input', id='name')
password = form.find('input', id='password')
service = form.find('input', type='hidden', id='service')
email = form.find('input', type='hidden', id='email_address')
form = page.find('form')
name = form.find('input', id='name')
password = form.find('input', id='password')
service = form.find('input', type='hidden', id='service')
email = form.find('input', type='hidden', id='email_address')
assert email
assert email.attrs['value'] == 'invited_user@test.gov.uk'
assert name
assert password
assert service
assert service.attrs['value'] == service_one['id']
assert email
assert email.attrs['value'] == 'invited_user@test.gov.uk'
assert name
assert password
assert service
assert service.attrs['value'] == service_one['id']
def test_cancelled_invited_user_accepts_invited_redirect_to_cancelled_invitation(
app_,
client,
service_one,
mocker,
mock_get_user,
mock_get_service,
):
with app_.test_request_context():
with app_.test_client() as client:
cancelled_invitation = create_sample_invite(mocker, service_one, status='cancelled')
mock_check_token_invite(mocker, cancelled_invitation)
response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'))
cancelled_invitation = create_sample_invite(mocker, service_one, status='cancelled')
mock_check_token_invite(mocker, cancelled_invitation)
response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'))
app.invite_api_client.check_token.assert_called_with('thisisnotarealtoken')
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'The invitation you were sent has been cancelled'
app.invite_api_client.check_token.assert_called_with('thisisnotarealtoken')
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'The invitation you were sent has been cancelled'
def test_new_user_accept_invite_completes_new_registration_redirects_to_verify(
app_,
client,
service_one,
sample_invite,
api_user_active,
@@ -251,43 +231,41 @@ def test_new_user_accept_invite_completes_new_registration_redirects_to_verify(
expected_from_user = service_one['users'][0]
expected_redirect_location = 'http://localhost/register-from-invite'
with app_.test_request_context():
with app_.test_client() as client:
response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'))
with client.session_transaction() as session:
assert response.status_code == 302
assert response.location == expected_redirect_location
invited_user = session.get('invited_user')
assert invited_user
assert expected_service == invited_user['service']
assert expected_email == invited_user['email_address']
assert expected_from_user == invited_user['from_user']
response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'))
with client.session_transaction() as session:
assert response.status_code == 302
assert response.location == expected_redirect_location
invited_user = session.get('invited_user')
assert invited_user
assert expected_service == invited_user['service']
assert expected_email == invited_user['email_address']
assert expected_from_user == invited_user['from_user']
data = {'service': invited_user['service'],
'email_address': invited_user['email_address'],
'from_user': invited_user['from_user'],
'password': 'longpassword',
'mobile_number': '+447890123456',
'name': 'Invited User'
}
data = {'service': invited_user['service'],
'email_address': invited_user['email_address'],
'from_user': invited_user['from_user'],
'password': 'longpassword',
'mobile_number': '+447890123456',
'name': 'Invited User'
}
expected_redirect_location = 'http://localhost/verify'
response = client.post(url_for('main.register_from_invite'), data=data)
assert response.status_code == 302
assert response.location == expected_redirect_location
expected_redirect_location = 'http://localhost/verify'
response = client.post(url_for('main.register_from_invite'), data=data)
assert response.status_code == 302
assert response.location == expected_redirect_location
mock_send_verify_code.assert_called_once_with(ANY, 'sms', data['mobile_number'])
mock_send_verify_code.assert_called_once_with(ANY, 'sms', data['mobile_number'])
mock_register_user.assert_called_with(data['name'],
data['email_address'],
data['mobile_number'],
data['password'])
mock_register_user.assert_called_with(data['name'],
data['email_address'],
data['mobile_number'],
data['password'])
assert mock_accept_invite.call_count == 1
assert mock_accept_invite.call_count == 1
def test_signed_in_existing_user_cannot_use_anothers_invite(
app_,
logged_in_client,
mocker,
api_user_active,
sample_invite,
@@ -299,24 +277,21 @@ def test_signed_in_existing_user_cannot_use_anothers_invite(
mocker.patch('app.invite_api_client.check_token', return_value=invite)
mocker.patch('app.user_api_client.get_users_for_service', return_value=[api_user_active])
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'), follow_redirects=True)
assert response.status_code == 403
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == '403'
flash_banners = page.find_all('div', class_='banner-dangerous')
assert len(flash_banners) == 1
banner_contents = flash_banners[0].text.strip()
assert "You’re signed in as test@user.gov.uk." in banner_contents
assert "This invite is for another email address." in banner_contents
assert "Sign out and click the link again to accept this invite." in banner_contents
assert mock_accept_invite.call_count == 0
response = logged_in_client.get(url_for('main.accept_invite', token='thisisnotarealtoken'), follow_redirects=True)
assert response.status_code == 403
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == '403'
flash_banners = page.find_all('div', class_='banner-dangerous')
assert len(flash_banners) == 1
banner_contents = flash_banners[0].text.strip()
assert "You’re signed in as test@user.gov.uk." in banner_contents
assert "This invite is for another email address." in banner_contents
assert "Sign out and click the link again to accept this invite." in banner_contents
assert mock_accept_invite.call_count == 0
def test_new_invited_user_verifies_and_added_to_service(
app_,
client,
service_one,
sample_invite,
api_user_active,
@@ -340,35 +315,33 @@ def test_new_invited_user_verifies_and_added_to_service(
mock_get_usage,
):
with app_.test_request_context():
with app_.test_client() as client:
# visit accept token page
response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'))
data = {'service': sample_invite['service'],
'email_address': sample_invite['email_address'],
'from_user': sample_invite['from_user'],
'password': 'longpassword',
'mobile_number': '+447890123456',
'name': 'Invited User'
}
# visit accept token page
response = client.get(url_for('main.accept_invite', token='thisisnotarealtoken'))
data = {'service': sample_invite['service'],
'email_address': sample_invite['email_address'],
'from_user': sample_invite['from_user'],
'password': 'longpassword',
'mobile_number': '+447890123456',
'name': 'Invited User'
}
# get redirected to register from invite
response = client.post(url_for('main.register_from_invite'), data=data)
# get redirected to register from invite
response = client.post(url_for('main.register_from_invite'), data=data)
# that sends user on to verify
response = client.post(url_for('main.verify'), data={'sms_code': '12345'}, follow_redirects=True)
# that sends user on to verify
response = client.post(url_for('main.verify'), data={'sms_code': '12345'}, follow_redirects=True)
# 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']
# 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)
mock_accept_invite.assert_called_with(data['service'], sample_invite['id'])
mock_check_verify_code.assert_called_once_with(new_user_id, '12345', 'sms')
assert service_one['id'] == session['service_id']
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)
mock_accept_invite.assert_called_with(data['service'], sample_invite['id'])
mock_check_verify_code.assert_called_once_with(new_user_id, '12345', 'sms')
assert service_one['id'] == session['service_id']
raw_html = response.data.decode('utf-8')
page = BeautifulSoup(raw_html, 'html.parser')
element = page.find('h2').text == 'Trial mode'
raw_html = response.data.decode('utf-8')
page = BeautifulSoup(raw_html, 'html.parser')
element = page.find('h2').text == 'Trial mode'

131
tests/app/main/views/test_add_service.py
View File

@@ -17,132 +17,117 @@ def test_non_gov_user_cannot_see_add_service_button(
def test_get_should_render_add_service_template(
app_,
logged_in_client,
api_user_active,
mocker,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active, mocker)
response = client.get(url_for('main.add_service'))
assert response.status_code == 200
assert 'Which service do you want to set up notifications for?' in response.get_data(as_text=True)
response = logged_in_client.get(url_for('main.add_service'))
assert response.status_code == 200
assert 'Which service do you want to set up notifications for?' in response.get_data(as_text=True)
def test_should_add_service_and_redirect_to_tour_when_no_services(
app_,
logged_in_client,
mocker,
mock_create_service,
mock_create_service_template,
mock_get_services_with_no_services,
api_user_active,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active, mocker)
response = client.post(
url_for('main.add_service'),
data={'name': 'testing the post'})
assert mock_get_services_with_no_services.called
mock_create_service.assert_called_once_with(
service_name='testing the post',
message_limit=app_.config['DEFAULT_SERVICE_LIMIT'],
restricted=True,
user_id=api_user_active.id,
email_from='testing.the.post'
)
assert len(mock_create_service_template.call_args_list) == 1
assert session['service_id'] == 101
assert response.status_code == 302
assert response.location == url_for(
'main.send_test',
service_id=101,
template_id="Example text message template",
help=1,
_external=True
)
response = logged_in_client.post(
url_for('main.add_service'),
data={'name': 'testing the post'})
assert mock_get_services_with_no_services.called
mock_create_service.assert_called_once_with(
service_name='testing the post',
message_limit=app_.config['DEFAULT_SERVICE_LIMIT'],
restricted=True,
user_id=api_user_active.id,
email_from='testing.the.post'
)
assert len(mock_create_service_template.call_args_list) == 1
assert session['service_id'] == 101
assert response.status_code == 302
assert response.location == url_for(
'main.send_test',
service_id=101,
template_id="Example text message template",
help=1,
_external=True
)
def test_should_add_service_and_redirect_to_dashboard_when_existing_service(
app_,
logged_in_client,
mocker,
mock_create_service,
mock_create_service_template,
mock_get_services,
api_user_active,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active, mocker)
response = client.post(
url_for('main.add_service'),
data={'name': 'testing the post'})
assert mock_get_services.called
mock_create_service.assert_called_once_with(
service_name='testing the post',
message_limit=app_.config['DEFAULT_SERVICE_LIMIT'],
restricted=True,
user_id=api_user_active.id,
email_from='testing.the.post'
)
assert len(mock_create_service_template.call_args_list) == 0
assert session['service_id'] == 101
assert response.status_code == 302
assert response.location == url_for('main.service_dashboard', service_id=101, _external=True)
response = logged_in_client.post(
url_for('main.add_service'),
data={'name': 'testing the post'})
assert mock_get_services.called
mock_create_service.assert_called_once_with(
service_name='testing the post',
message_limit=app_.config['DEFAULT_SERVICE_LIMIT'],
restricted=True,
user_id=api_user_active.id,
email_from='testing.the.post'
)
assert len(mock_create_service_template.call_args_list) == 0
assert session['service_id'] == 101
assert response.status_code == 302
assert response.location == url_for('main.service_dashboard', service_id=101, _external=True)
def test_should_return_form_errors_when_service_name_is_empty(
app_,
logged_in_client,
mocker,
api_user_active,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active, mocker)
response = client.post(url_for('main.add_service'), data={})
assert response.status_code == 200
assert 'Can’t be empty' in response.get_data(as_text=True)
response = logged_in_client.post(url_for('main.add_service'), data={})
assert response.status_code == 200
assert 'Can’t be empty' in response.get_data(as_text=True)
def test_should_return_form_errors_with_duplicate_service_name_regardless_of_case(
app_,
logged_in_client,
mocker,
service_one,
api_user_active,
mock_create_service,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active, mocker, service_one)
mocker.patch('app.service_api_client.find_all_service_email_from',
return_value=['service_one', 'service.two'])
response = client.post(url_for('main.add_service'), data={'name': 'SERVICE TWO'})
mocker.patch('app.service_api_client.find_all_service_email_from',
return_value=['service_one', 'service.two'])
response = logged_in_client.post(url_for('main.add_service'), data={'name': 'SERVICE TWO'})
assert response.status_code == 200
assert 'This service name is already in use' in response.get_data(as_text=True)
app.service_api_client.find_all_service_email_from.assert_called_once_with()
assert not mock_create_service.called
assert response.status_code == 200
assert 'This service name is already in use' in response.get_data(as_text=True)
app.service_api_client.find_all_service_email_from.assert_called_once_with()
assert not mock_create_service.called
def test_non_whitelist_user_cannot_access_create_service_page(
client,
logged_in_client,
mock_login,
mock_get_non_govuser,
api_nongov_user_active,
):
client.login(api_nongov_user_active)
assert not is_gov_user(api_nongov_user_active.email_address)
response = client.get(url_for('main.add_service'))
response = logged_in_client.get(url_for('main.add_service'))
assert response.status_code == 403
def test_non_whitelist_user_cannot_create_service(
client,
logged_in_client,
mock_login,
mock_get_non_govuser,
api_nongov_user_active,
):
client.login(api_nongov_user_active)
assert not is_gov_user(api_nongov_user_active.email_address)
response = client.post(url_for('main.add_service'), data={'name': 'SERVICE TWO'})
response = logged_in_client.post(url_for('main.add_service'), data={'name': 'SERVICE TWO'})
assert response.status_code == 403

163
tests/app/main/views/test_api_keys.py
View File

@@ -9,35 +9,32 @@ from tests import validate_route_permission
def test_should_show_api_page(
app_,
logged_in_client,
mock_login,
api_user_active,
mock_get_service,
mock_has_permissions,
mock_get_notifications
):
with app_.test_request_context(), app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.api_integration', service_id=str(uuid.uuid4())))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'API integration'
rows = page.find_all('details')
assert len(rows) == 5
for index, row in enumerate(rows):
assert row.find('h3').string.strip() == '07123456789'
response = logged_in_client.get(url_for('main.api_integration', service_id=str(uuid.uuid4())))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'API integration'
rows = page.find_all('details')
assert len(rows) == 5
for index, row in enumerate(rows):
assert row.find('h3').string.strip() == '07123456789'
def test_should_show_api_page_with_lots_of_notifications(
client,
logged_in_client,
mock_login,
api_user_active,
mock_get_service,
mock_has_permissions,
mock_get_notifications_with_previous_next
):
client.login(api_user_active)
response = client.get(url_for('main.api_integration', service_id=str(uuid.uuid4())))
response = logged_in_client.get(url_for('main.api_integration', service_id=str(uuid.uuid4())))
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
rows = page.find_all('div', {'class': 'api-notifications-item'})
assert ' '.join(rows[len(rows) - 1].text.split()) == (
@@ -46,71 +43,64 @@ def test_should_show_api_page_with_lots_of_notifications(
def test_should_show_api_page_with_no_notifications(
client,
logged_in_client,
mock_login,
api_user_active,
mock_get_service,
mock_has_permissions,
mock_get_notifications_with_no_notifications
):
client.login(api_user_active)
response = client.get(url_for('main.api_integration', service_id=str(uuid.uuid4())))
response = logged_in_client.get(url_for('main.api_integration', service_id=str(uuid.uuid4())))
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
rows = page.find_all('div', {'class': 'api-notifications-item'})
assert 'When you send messages via the API they’ll appear here.' in rows[len(rows) - 1].text.strip()
def test_should_show_api_page_for_live_service(
app_,
logged_in_client,
mock_login,
api_user_active,
mock_get_live_service,
mock_has_permissions
):
with app_.test_request_context(), app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.api_integration', service_id=str(uuid.uuid4())))
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert 'Your service is in trial mode' not in page.find('main').text
response = logged_in_client.get(url_for('main.api_integration', service_id=str(uuid.uuid4())))
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert 'Your service is in trial mode' not in page.find('main').text
def test_should_show_api_documentation_page(
app_,
logged_in_client,
mock_login,
api_user_active,
mock_get_service,
mock_has_permissions
):
with app_.test_request_context(), app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.api_documentation', service_id=str(uuid.uuid4())))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'Documentation'
response = logged_in_client.get(url_for('main.api_documentation', service_id=str(uuid.uuid4())))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'Documentation'
def test_should_show_empty_api_keys_page(
app_,
client,
api_user_pending,
mock_login,
mock_get_no_api_keys,
mock_get_service,
mock_has_permissions,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_pending)
service_id = str(uuid.uuid4())
response = client.get(url_for('main.api_keys', service_id=service_id))
client.login(api_user_pending)
service_id = str(uuid.uuid4())
response = client.get(url_for('main.api_keys', service_id=service_id))
assert response.status_code == 200
assert 'You haven’t created any API keys yet' in response.get_data(as_text=True)
assert 'Create an API key' in response.get_data(as_text=True)
mock_get_no_api_keys.assert_called_once_with(service_id=service_id)
assert response.status_code == 200
assert 'You haven’t created any API keys yet' in response.get_data(as_text=True)
assert 'Create an API key' in response.get_data(as_text=True)
mock_get_no_api_keys.assert_called_once_with(service_id=service_id)
def test_should_show_api_keys_page(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_get_api_keys,
@@ -118,21 +108,18 @@ def test_should_show_api_keys_page(
mock_has_permissions,
fake_uuid,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.api_keys', service_id=fake_uuid))
response = logged_in_client.get(url_for('main.api_keys', service_id=fake_uuid))
assert response.status_code == 200
resp_data = response.get_data(as_text=True)
assert 'some key name' in resp_data
assert 'another key name' in resp_data
assert 'Revoked 1 January at 1:00am' in resp_data
mock_get_api_keys.assert_called_once_with(service_id=fake_uuid)
assert response.status_code == 200
resp_data = response.get_data(as_text=True)
assert 'some key name' in resp_data
assert 'another key name' in resp_data
assert 'Revoked 1 January at 1:00am' in resp_data
mock_get_api_keys.assert_called_once_with(service_id=fake_uuid)
def test_should_show_create_api_key_page(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_get_api_keys,
@@ -140,17 +127,15 @@ def test_should_show_create_api_key_page(
mock_has_permissions,
fake_uuid,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
service_id = fake_uuid
response = client.get(url_for('main.create_api_key', service_id=fake_uuid))
logged_in_client.login(api_user_active)
service_id = fake_uuid
response = logged_in_client.get(url_for('main.create_api_key', service_id=fake_uuid))
assert response.status_code == 200
assert response.status_code == 200
def test_should_create_api_key_with_type_normal(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_get_api_keys,
@@ -162,15 +147,13 @@ def test_should_create_api_key_with_type_normal(
post = mocker.patch('app.notify_client.api_key_api_client.ApiKeyApiClient.post', return_value={'data': fake_uuid})
service_id = str(uuid.uuid4())
with app_.test_request_context(), app_.test_client() as client:
client.login(api_user_active)
response = client.post(
url_for('main.create_api_key', service_id=service_id),
data={
'key_name': 'Some default key name 1/2',
'key_type': 'normal'
}
)
response = logged_in_client.post(
url_for('main.create_api_key', service_id=service_id),
data={
'key_name': 'Some default key name 1/2',
'key_type': 'normal'
}
)
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
@@ -190,7 +173,7 @@ def test_should_create_api_key_with_type_normal(
def test_cant_create_normal_api_key_in_trial_mode(
client,
logged_in_client,
api_user_active,
mock_login,
mock_get_api_keys,
@@ -201,8 +184,7 @@ def test_cant_create_normal_api_key_in_trial_mode(
):
mock_post = mocker.patch('app.notify_client.api_key_api_client.ApiKeyApiClient.post')
client.login(api_user_active)
response = client.post(
response = logged_in_client.post(
url_for('main.create_api_key', service_id=uuid.uuid4()),
data={
'key_name': 'some default key name',
@@ -214,7 +196,7 @@ def test_cant_create_normal_api_key_in_trial_mode(
def test_should_show_confirm_revoke_api_key(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_get_api_keys,
@@ -222,18 +204,14 @@ def test_should_show_confirm_revoke_api_key(
mock_has_permissions,
fake_uuid,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.revoke_api_key', service_id=fake_uuid, key_id=fake_uuid))
assert response.status_code == 200
assert 'some key name' in response.get_data(as_text=True)
mock_get_api_keys.assert_called_once_with(service_id=fake_uuid, key_id=fake_uuid)
response = logged_in_client.get(url_for('main.revoke_api_key', service_id=fake_uuid, key_id=fake_uuid))
assert response.status_code == 200
assert 'some key name' in response.get_data(as_text=True)
mock_get_api_keys.assert_called_once_with(service_id=fake_uuid, key_id=fake_uuid)
def test_should_redirect_after_revoking_api_key(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_revoke_api_key,
@@ -242,15 +220,12 @@ def test_should_redirect_after_revoking_api_key(
mock_has_permissions,
fake_uuid,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.post(url_for('main.revoke_api_key', service_id=fake_uuid, key_id=fake_uuid))
response = logged_in_client.post(url_for('main.revoke_api_key', service_id=fake_uuid, key_id=fake_uuid))
assert response.status_code == 302
assert response.location == url_for('.api_keys', service_id=fake_uuid, _external=True)
mock_revoke_api_key.assert_called_once_with(service_id=fake_uuid, key_id=fake_uuid)
mock_get_api_keys.assert_called_once_with(service_id=fake_uuid, key_id=fake_uuid)
assert response.status_code == 302
assert response.location == url_for('.api_keys', service_id=fake_uuid, _external=True)
mock_revoke_api_key.assert_called_once_with(service_id=fake_uuid, key_id=fake_uuid)
mock_get_api_keys.assert_called_once_with(service_id=fake_uuid, key_id=fake_uuid)
@pytest.mark.parametrize('route', [
@@ -304,15 +279,14 @@ def test_route_invalid_permissions(
def test_should_show_whitelist_page(
client,
logged_in_client,
mock_login,
api_user_active,
mock_get_service,
mock_has_permissions,
mock_get_whitelist,
):
client.login(api_user_active)
response = client.get(url_for('main.whitelist', service_id=str(uuid.uuid4())))
response = logged_in_client.get(url_for('main.whitelist', service_id=str(uuid.uuid4())))
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
textboxes = page.find_all('input', {'type': 'text'})
for index, value in enumerate(
@@ -322,14 +296,13 @@ def test_should_show_whitelist_page(
def test_should_update_whitelist(
client,
logged_in_client,
mock_login,
api_user_active,
mock_get_service,
mock_has_permissions,
mock_update_whitelist
):
client.login(api_user_active)
service_id = str(uuid.uuid4())
data = OrderedDict([
('email_addresses-1', 'test@example.com'),
@@ -337,7 +310,7 @@ def test_should_update_whitelist(
('phone_numbers-0', '07900900000')
])
response = client.post(
response = logged_in_client.post(
url_for('main.whitelist', service_id=service_id),
data=data
)

82
tests/app/main/views/test_choose_services.py
View File

@@ -2,35 +2,31 @@ from flask import url_for
def test_should_show_choose_services_page(
app_,
logged_in_client,
mock_login,
mock_get_user,
api_user_active,
mock_get_services,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.choose_service'))
response = logged_in_client.get(url_for('main.choose_service'))
assert response.status_code == 200
resp_data = response.get_data(as_text=True)
assert 'Choose service' in resp_data
services = mock_get_services.side_effect()
assert mock_get_services.called
assert services['data'][0]['name'] in resp_data
assert services['data'][1]['name'] in resp_data
assert response.status_code == 200
resp_data = response.get_data(as_text=True)
assert 'Choose service' in resp_data
services = mock_get_services.side_effect()
assert mock_get_services.called
assert services['data'][0]['name'] in resp_data
assert services['data'][1]['name'] in resp_data
def test_should_show_choose_services_page_if_no_services(
client,
logged_in_client,
mock_login,
api_user_active,
):
# if users last service has been archived there'll be no services
# mock_login already patches get_services to return no data
client.login(api_user_active)
response = client.get(url_for('main.choose_service'))
response = logged_in_client.get(url_for('main.choose_service'))
assert response.status_code == 200
resp_data = response.get_data(as_text=True)
assert 'Choose service' in resp_data
@@ -38,62 +34,52 @@ def test_should_show_choose_services_page_if_no_services(
def test_redirect_if_only_one_service(
app_,
logged_in_client,
mock_login,
api_user_active,
mock_get_services_with_one_service,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.show_all_services_or_dashboard'))
response = logged_in_client.get(url_for('main.show_all_services_or_dashboard'))
service = mock_get_services_with_one_service.side_effect()['data'][0]
assert response.status_code == 302
assert response.location == url_for('main.service_dashboard', service_id=service['id'], _external=True)
service = mock_get_services_with_one_service.side_effect()['data'][0]
assert response.status_code == 302
assert response.location == url_for('main.service_dashboard', service_id=service['id'], _external=True)
def test_redirect_if_multiple_services(
app_,
logged_in_client,
mock_login,
api_user_active,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.show_all_services_or_dashboard'))
response = logged_in_client.get(url_for('main.show_all_services_or_dashboard'))
assert response.status_code == 302
assert response.location == url_for('main.choose_service', _external=True)
assert response.status_code == 302
assert response.location == url_for('main.choose_service', _external=True)
def test_redirect_if_service_in_session(
app_,
logged_in_client,
mock_login,
api_user_active,
mock_get_services,
mock_get_service,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
with client.session_transaction() as session:
session['service_id'] = '147ad62a-2951-4fa1-9ca0-093cd1a52c52'
response = client.get(url_for('main.show_all_services_or_dashboard'))
with logged_in_client.session_transaction() as session:
session['service_id'] = '147ad62a-2951-4fa1-9ca0-093cd1a52c52'
response = logged_in_client.get(url_for('main.show_all_services_or_dashboard'))
assert response.status_code == 302
assert response.location == url_for(
'main.service_dashboard',
service_id='147ad62a-2951-4fa1-9ca0-093cd1a52c52',
_external=True
)
assert response.status_code == 302
assert response.location == url_for(
'main.service_dashboard',
service_id='147ad62a-2951-4fa1-9ca0-093cd1a52c52',
_external=True
)
def test_should_redirect_if_not_logged_in(
logged_in_client,
app_
):
with app_.test_request_context():
with app_.test_client() as client:
response = client.get(url_for('main.show_all_services_or_dashboard'))
assert response.status_code == 302
assert url_for('main.index', _external=True) in response.location
response = logged_in_client.get(url_for('main.show_all_services_or_dashboard'))
assert response.status_code == 302
assert url_for('main.index', _external=True) in response.location

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

@@ -4,55 +4,50 @@ from bs4 import BeautifulSoup
def test_should_render_email_verification_resend_show_email_address_and_resend_verify_email(
app_,
client,
mocker,
api_user_active,
mock_get_user_by_email,
mock_send_verify_email,
):
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.resend_email_verification'))
assert response.status_code == 200
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.resend_email_verification'))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string == 'Check your email'
expected = "A new confirmation email has been sent to {}".format(api_user_active.email_address)
assert page.h1.string == 'Check your email'
expected = "A new confirmation email has been sent to {}".format(api_user_active.email_address)
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)
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_correct_resend_template_for_active_user(
app_,
client,
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_text_code'))
assert response.status_code == 200
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_text_code'))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string == 'Resend security code'
# there shouldn't be a form for updating mobile number
assert page.find('form') is None
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string == 'Resend security code'
# there shouldn't be a form for updating mobile number
assert page.find('form') is None
def test_should_render_correct_resend_template_for_pending_user(
app_,
client,
mocker,
api_user_pending,
mock_send_verify_code,
@@ -60,26 +55,24 @@ def test_should_render_correct_resend_template_for_pending_user(
mocker.patch('app.user_api_client.get_user_by_email', return_value=api_user_pending)
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_details'] = {
'id': api_user_pending.id,
'email': api_user_pending.email_address}
response = client.get(url_for('main.check_and_resend_text_code'))
assert response.status_code == 200
with client.session_transaction() as session:
session['user_details'] = {
'id': api_user_pending.id,
'email': api_user_pending.email_address}
response = client.get(url_for('main.check_and_resend_text_code'))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string == 'Check your mobile number'
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string == 'Check your mobile number'
expected = 'Check your mobile phone number is correct and then resend the security code.'
message = page.find_all('p')[1].text
assert message == expected
assert page.find('form').input['value'] == api_user_pending.mobile_number
expected = 'Check your mobile phone number is correct and then resend the security code.'
message = page.find_all('p')[1].text
assert message == expected
assert page.find('form').input['value'] == api_user_pending.mobile_number
def test_should_resend_verify_code_and_update_mobile_for_pending_user(
app_,
client,
mocker,
api_user_pending,
mock_update_user,
@@ -88,40 +81,36 @@ def test_should_resend_verify_code_and_update_mobile_for_pending_user(
mocker.patch('app.user_api_client.get_user_by_email', return_value=api_user_pending)
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_details'] = {
'id': api_user_pending.id,
'email': api_user_pending.email_address}
response = client.post(url_for('main.check_and_resend_text_code'),
data={'mobile_number': '+447700900460'})
assert response.status_code == 302
assert response.location == url_for('main.verify', _external=True)
with client.session_transaction() as session:
session['user_details'] = {
'id': api_user_pending.id,
'email': api_user_pending.email_address}
response = client.post(url_for('main.check_and_resend_text_code'),
data={'mobile_number': '+447700900460'})
assert response.status_code == 302
assert response.location == url_for('main.verify', _external=True)
mock_update_user.assert_called_once_with(api_user_pending)
mock_send_verify_code.assert_called_once_with(api_user_pending.id, 'sms', to='+447700900460')
mock_update_user.assert_called_once_with(api_user_pending)
mock_send_verify_code.assert_called_once_with(api_user_pending.id, 'sms', to='+447700900460')
def test_check_and_redirect_to_two_factor_if_user_active(
app_,
client,
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_verification_code'))
assert response.status_code == 302
assert response.location == url_for('main.two_factor', _external=True)
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_verification_code'))
assert response.status_code == 302
assert response.location == url_for('main.two_factor', _external=True)
def test_check_and_redirect_to_verify_if_user_pending(
app_,
client,
mocker,
api_user_pending,
mock_get_user_pending,
@@ -130,15 +119,13 @@ def test_check_and_redirect_to_verify_if_user_pending(
mocker.patch('app.user_api_client.get_user_by_email', return_value=api_user_pending)
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_details'] = {
'id': api_user_pending.id,
'email': api_user_pending.email_address}
response = client.get(url_for('main.check_and_resend_verification_code'))
assert response.status_code == 302
assert response.location == url_for('main.verify', _external=True)
with client.session_transaction() as session:
session['user_details'] = {
'id': api_user_pending.id,
'email': api_user_pending.email_address}
response = client.get(url_for('main.check_and_resend_verification_code'))
assert response.status_code == 302
assert response.location == url_for('main.verify', _external=True)
@pytest.mark.parametrize('endpoint', [
@@ -147,11 +134,10 @@ def test_check_and_redirect_to_verify_if_user_pending(
'main.check_and_resend_verification_code',
])
def test_redirect_to_sign_in_if_not_logged_in(
app_,
client,
endpoint,
):
with app_.test_request_context(), app_.test_client() as client:
response = client.get(url_for(endpoint))
response = client.get(url_for(endpoint))
assert response.location == url_for('main.sign_in', _external=True)
assert response.status_code == 302
assert response.location == url_for('main.sign_in', _external=True)
assert response.status_code == 302

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

@@ -32,7 +32,7 @@ stub_template_stats = [
def test_get_started(
app_,
logged_in_client,
mocker,
api_user_active,
mock_get_service,
@@ -48,9 +48,7 @@ def test_get_started(
mock_template_stats = mocker.patch('app.template_statistics_client.get_template_statistics_for_service',
return_value=copy.deepcopy(stub_template_stats))
with app_.test_request_context(), app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.service_dashboard', service_id=SERVICE_ONE_ID))
response = logged_in_client.get(url_for('main.service_dashboard', service_id=SERVICE_ONE_ID))
# mock_get_service_templates_when_no_templates_exist.assert_called_once_with(SERVICE_ONE_ID)
assert response.status_code == 200
@@ -58,7 +56,7 @@ def test_get_started(
def test_get_started_is_hidden_once_templates_exist(
app_,
logged_in_client,
mocker,
api_user_active,
mock_get_service,
@@ -73,9 +71,7 @@ def test_get_started_is_hidden_once_templates_exist(
):
mock_template_stats = mocker.patch('app.template_statistics_client.get_template_statistics_for_service',
return_value=copy.deepcopy(stub_template_stats))
with app_.test_request_context(), app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.service_dashboard', service_id=SERVICE_ONE_ID))
response = logged_in_client.get(url_for('main.service_dashboard', service_id=SERVICE_ONE_ID))
# mock_get_service_templates.assert_called_once_with(SERVICE_ONE_ID)
assert response.status_code == 200
@@ -83,7 +79,7 @@ def test_get_started_is_hidden_once_templates_exist(
def test_should_show_recent_templates_on_dashboard(
app_,
logged_in_client,
mocker,
api_user_active,
mock_get_service,
@@ -99,35 +95,32 @@ def test_should_show_recent_templates_on_dashboard(
mock_template_stats = mocker.patch('app.template_statistics_client.get_template_statistics_for_service',
return_value=copy.deepcopy(stub_template_stats))
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.service_dashboard', service_id=SERVICE_ONE_ID))
response = logged_in_client.get(url_for('main.service_dashboard', service_id=SERVICE_ONE_ID))
assert response.status_code == 200
response.get_data(as_text=True)
mock_template_stats.assert_called_once_with(SERVICE_ONE_ID, limit_days=7)
assert response.status_code == 200
response.get_data(as_text=True)
mock_template_stats.assert_called_once_with(SERVICE_ONE_ID, limit_days=7)
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
headers = [header.text.strip() for header in page.find_all('h2') + page.find_all('h1')]
assert 'Test Service' in headers
assert 'In the last 7 days' in headers
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
headers = [header.text.strip() for header in page.find_all('h2') + page.find_all('h1')]
assert 'Test Service' in headers
assert 'In the last 7 days' in headers
table_rows = page.find_all('tbody')[1].find_all('tr')
table_rows = page.find_all('tbody')[1].find_all('tr')
assert len(table_rows) == 2
assert len(table_rows) == 2
assert 'two' in table_rows[0].find_all('th')[0].text
assert 'Email template' in table_rows[0].find_all('th')[0].text
assert '200' in table_rows[0].find_all('td')[0].text
assert 'two' in table_rows[0].find_all('th')[0].text
assert 'Email template' in table_rows[0].find_all('th')[0].text
assert '200' in table_rows[0].find_all('td')[0].text
assert 'one' in table_rows[1].find_all('th')[0].text
assert 'Text message template' in table_rows[1].find_all('th')[0].text
assert '100' in table_rows[1].find_all('td')[0].text
assert 'one' in table_rows[1].find_all('th')[0].text
assert 'Text message template' in table_rows[1].find_all('th')[0].text
assert '100' in table_rows[1].find_all('td')[0].text
def test_should_show_all_templates_on_template_statistics_page(
app_,
logged_in_client,
mocker,
api_user_active,
mock_get_service,
@@ -141,32 +134,29 @@ def test_should_show_all_templates_on_template_statistics_page(
mock_template_stats = mocker.patch('app.template_statistics_client.get_template_statistics_for_service',
return_value=copy.deepcopy(stub_template_stats))
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.template_history', service_id=SERVICE_ONE_ID))
response = logged_in_client.get(url_for('main.template_history', service_id=SERVICE_ONE_ID))
assert response.status_code == 200
response.get_data(as_text=True)
mock_template_stats.assert_called_once_with(SERVICE_ONE_ID)
assert response.status_code == 200
response.get_data(as_text=True)
mock_template_stats.assert_called_once_with(SERVICE_ONE_ID)
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
table_rows = page.find_all('tbody')[0].find_all('tr')
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
table_rows = page.find_all('tbody')[0].find_all('tr')
assert len(table_rows) == 2
assert len(table_rows) == 2
assert 'two' in table_rows[0].find_all('th')[0].text
assert 'Email template' in table_rows[0].find_all('th')[0].text
assert '200' in table_rows[0].find_all('td')[0].text
assert 'two' in table_rows[0].find_all('th')[0].text
assert 'Email template' in table_rows[0].find_all('th')[0].text
assert '200' in table_rows[0].find_all('td')[0].text
assert 'one' in table_rows[1].find_all('th')[0].text
assert 'Text message template' in table_rows[1].find_all('th')[0].text
assert '100' in table_rows[1].find_all('td')[0].text
assert 'one' in table_rows[1].find_all('th')[0].text
assert 'Text message template' in table_rows[1].find_all('th')[0].text
assert '100' in table_rows[1].find_all('td')[0].text
@freeze_time("2016-01-01 11:09:00.061258")
def test_should_show_upcoming_jobs_on_dashboard(
app_,
logged_in_client,
mocker,
api_user_active,
mock_get_service,
@@ -180,9 +170,7 @@ def test_should_show_upcoming_jobs_on_dashboard(
mock_has_permissions,
mock_get_usage,
):
with app_.test_request_context(), app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.service_dashboard', service_id=SERVICE_ONE_ID))
response = logged_in_client.get(url_for('main.service_dashboard', service_id=SERVICE_ONE_ID))
first_call = mock_get_jobs.call_args_list[0]
assert first_call[0] == (SERVICE_ONE_ID,)
@@ -205,7 +193,7 @@ def test_should_show_upcoming_jobs_on_dashboard(
@freeze_time("2016-01-01 11:09:00.061258")
def test_should_show_recent_jobs_on_dashboard(
app_,
logged_in_client,
mocker,
api_user_active,
mock_get_service,
@@ -219,9 +207,7 @@ def test_should_show_recent_jobs_on_dashboard(
mock_has_permissions,
mock_get_usage,
):
with app_.test_request_context(), app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.service_dashboard', service_id=SERVICE_ONE_ID))
response = logged_in_client.get(url_for('main.service_dashboard', service_id=SERVICE_ONE_ID))
second_call = mock_get_jobs.call_args_list[1]
assert second_call[0] == (SERVICE_ONE_ID,)
@@ -249,7 +235,7 @@ def test_should_show_recent_jobs_on_dashboard(
@freeze_time("2016-12-31 11:09:00.061258")
def test_usage_page(
client,
logged_in_client,
api_user_active,
mock_get_service,
mock_get_user,
@@ -257,8 +243,7 @@ def test_usage_page(
mock_get_usage,
mock_get_billable_units,
):
client.login(api_user_active)
response = client.get(url_for('main.usage', service_id=SERVICE_ONE_ID, year=2000))
response = logged_in_client.get(url_for('main.usage', service_id=SERVICE_ONE_ID, year=2000))
assert response.status_code == 200
@@ -288,14 +273,13 @@ def test_usage_page(
@freeze_time("2016-12-31 11:09:00.061258")
def test_usage_page_for_invalid_year(
client,
logged_in_client,
api_user_active,
mock_get_service,
mock_get_user,
mock_has_permissions,
):
client.login(api_user_active)
assert client.get(url_for('main.usage', service_id=SERVICE_ONE_ID, year='abcd')).status_code == 404
assert logged_in_client.get(url_for('main.usage', service_id=SERVICE_ONE_ID, year='abcd')).status_code == 404
def _test_dashboard_menu(mocker, app_, usr, service, permissions):
@@ -481,7 +465,7 @@ def test_aggregate_template_stats():
def test_service_dashboard_updates_gets_dashboard_totals(
mocker,
app_,
logged_in_client,
active_user_with_permissions,
service_one,
mock_get_user,
@@ -496,9 +480,7 @@ def test_service_dashboard_updates_gets_dashboard_totals(
'sms': {'requested': 456, 'delivered': 0, 'failed': 0}
})
with app_.test_request_context(), app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service_one)
response = client.get(url_for('main.service_dashboard', service_id=SERVICE_ONE_ID))
response = logged_in_client.get(url_for('main.service_dashboard', service_id=SERVICE_ONE_ID))
assert response.status_code == 200

15
tests/app/main/views/test_email_preview.py
View File

@@ -8,14 +8,13 @@ from flask import url_for
({'govuk_banner': 'false'}, 'false')
]
)
def test_renders(app_, mocker, query_args, result):
with app_.test_request_context(), app_.test_client() as client:
def test_renders(client, mocker, query_args, result):
mock_convert_to_boolean = mocker.patch('app.main.views.index.convert_to_boolean')
mocker.patch('app.main.views.index.HTMLEmailTemplate.__str__', return_value='rendered')
mock_convert_to_boolean = mocker.patch('app.main.views.index.convert_to_boolean')
mocker.patch('app.main.views.index.HTMLEmailTemplate.__str__', return_value='rendered')
response = client.get(url_for('main.email_template', **query_args))
response = client.get(url_for('main.email_template', **query_args))
assert response.status_code == 200
assert response.get_data(as_text=True) == 'rendered'
mock_convert_to_boolean.assert_called_once_with(result)
assert response.status_code == 200
assert response.get_data(as_text=True) == 'rendered'
mock_convert_to_boolean.assert_called_once_with(result)

53
tests/app/main/views/test_forgot_password.py
View File

@@ -7,12 +7,11 @@ from tests.conftest import api_user_active as create_active_user
import app
def test_should_render_forgot_password(app_):
with app_.test_request_context():
response = app_.test_client().get(url_for('.forgot_password'))
assert response.status_code == 200
assert 'We’ll send you an email to create a new password.' \
in response.get_data(as_text=True)
def test_should_render_forgot_password(client):
response = client.get(url_for('.forgot_password'))
assert response.status_code == 200
assert 'We’ll send you an email to create a new password.' \
in response.get_data(as_text=True)
@pytest.mark.parametrize('email_address', [
@@ -20,36 +19,34 @@ def test_should_render_forgot_password(app_):
'someuser@notonwhitelist.com'
])
def test_should_redirect_to_password_reset_sent_for_valid_email(
app_,
client,
fake_uuid,
email_address,
mocker,
):
with app_.test_request_context():
sample_user = create_active_user(fake_uuid, email_address=email_address)
mocker.patch('app.user_api_client.send_reset_password_url', return_value=None)
response = app_.test_client().post(
url_for('.forgot_password'),
data={'email_address': sample_user.email_address})
assert response.status_code == 200
assert 'Click the link in the email to reset your password.' \
in response.get_data(as_text=True)
app.user_api_client.send_reset_password_url.assert_called_once_with(sample_user.email_address)
sample_user = create_active_user(fake_uuid, email_address=email_address)
mocker.patch('app.user_api_client.send_reset_password_url', return_value=None)
response = client.post(
url_for('.forgot_password'),
data={'email_address': sample_user.email_address})
assert response.status_code == 200
assert 'Click the link in the email to reset your password.' \
in response.get_data(as_text=True)
app.user_api_client.send_reset_password_url.assert_called_once_with(sample_user.email_address)
def test_should_redirect_to_password_reset_sent_for_missing_email(
app_,
client,
api_user_active,
mocker,
):
with app_.test_request_context():
mocker.patch('app.user_api_client.send_reset_password_url', side_effect=HTTPError(Response(status=404),
'Not found'))
response = app_.test_client().post(
url_for('.forgot_password'),
data={'email_address': api_user_active.email_address})
assert response.status_code == 200
assert 'Click the link in the email to reset your password.' \
in response.get_data(as_text=True)
app.user_api_client.send_reset_password_url.assert_called_once_with(api_user_active.email_address)
mocker.patch('app.user_api_client.send_reset_password_url', side_effect=HTTPError(Response(status=404),
'Not found'))
response = client.post(
url_for('.forgot_password'),
data={'email_address': api_user_active.email_address})
assert response.status_code == 200
assert 'Click the link in the email to reset your password.' \
in response.get_data(as_text=True)
app.user_api_client.send_reset_password_url.assert_called_once_with(api_user_active.email_address)

5
tests/app/main/views/test_headers.py
View File

@@ -1,7 +1,6 @@
def test_owasp_useful_headers_set(app_):
with app_.test_request_context():
response = app_.test_client().get('/')
def test_owasp_useful_headers_set(client):
response = client.get('/')
assert response.status_code == 200
assert response.headers['X-Frame-Options'] == 'deny'
assert response.headers['X-Content-Type-Options'] == 'nosniff'

23
tests/app/main/views/test_index.py
View File

@@ -3,26 +3,25 @@ from flask import url_for
def test_logged_in_user_redirects_to_choose_service(
app_,
logged_in_client,
api_user_active,
mock_get_user,
mock_get_user_by_email,
mock_login,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.get(url_for('main.index'))
assert response.status_code == 302
response = logged_in_client.get(url_for('main.index'))
assert response.status_code == 302
response = client.get(url_for('main.sign_in', follow_redirects=True))
assert response.location == url_for('main.choose_service', _external=True)
response = logged_in_client.get(url_for('main.sign_in', follow_redirects=True))
assert response.location == url_for('main.choose_service', _external=True)
@pytest.mark.parametrize('view', [
'cookies', 'trial_mode', 'pricing', 'terms', 'delivery_and_failure', 'integration_testing'
])
def test_static_pages(app_, view):
with app_.test_request_context(), app_.test_client() as client:
response = client.get(url_for('main.{}'.format(view)))
assert response.status_code == 200
def test_static_pages(
client,
view,
):
response = client.get(url_for('main.{}'.format(view)))
assert response.status_code == 200

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

@@ -34,14 +34,13 @@ def _csv_notifications(notifications_json):
def test_get_jobs_should_return_list_of_all_real_jobs(
client,
logged_in_client,
service_one,
active_user_with_permissions,
mock_get_jobs,
mocker,
):
client.login(active_user_with_permissions, mocker, service_one)
response = client.get(url_for('main.view_jobs', service_id=service_one['id']))
response = logged_in_client.get(url_for('main.view_jobs', service_id=service_one['id']))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
@@ -51,14 +50,13 @@ def test_get_jobs_should_return_list_of_all_real_jobs(
def test_get_jobs_shows_page_links(
client,
logged_in_client,
service_one,
active_user_with_permissions,
mock_get_jobs,
mocker,
):
client.login(active_user_with_permissions, mocker, service_one)
response = client.get(url_for('main.view_jobs', service_id=service_one['id']))
response = logged_in_client.get(url_for('main.view_jobs', service_id=service_one['id']))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
@@ -88,7 +86,7 @@ def test_get_jobs_shows_page_links(
)
@freeze_time("2016-01-01 11:09:00.061258")
def test_should_show_page_for_one_job(
app_,
logged_in_client,
service_one,
active_user_with_permissions,
mock_get_service_template,
@@ -99,43 +97,41 @@ def test_should_show_page_for_one_job(
status_argument,
expected_api_call,
):
with app_.test_request_context(), app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service_one)
response = client.get(url_for(
'main.view_job',
service_id=service_one['id'],
job_id=fake_uuid,
status=status_argument
))
response = logged_in_client.get(url_for(
'main.view_job',
service_id=service_one['id'],
job_id=fake_uuid,
status=status_argument
))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.text.strip() == 'thisisatest.csv'
assert page.find('div', {'class': 'sms-message-wrapper'}).text.strip() == (
'{}: Template <em>content</em> with & entity'.format(service_one['name'])
)
assert ' '.join(page.find('tbody').find('tr').text.split()) == (
'07123456789 Delivered 1 January at 11:10am'
)
assert page.find('div', {'data-key': 'notifications'})['data-resource'] == url_for(
'main.view_job_updates',
service_id=service_one['id'],
job_id=fake_uuid,
status=status_argument,
)
csv_link = page.find('a', {'download': 'download'})
assert csv_link['href'] == url_for(
'main.view_job_csv',
service_id=service_one['id'],
job_id=fake_uuid,
status=status_argument
)
assert csv_link.text == 'Download this report'
assert page.find('span', {'id': 'time-left'}).text == 'Data available for 7 days'
mock_get_notifications.assert_called_with(
service_one['id'],
fake_uuid,
status=expected_api_call
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.text.strip() == 'thisisatest.csv'
assert page.find('div', {'class': 'sms-message-wrapper'}).text.strip() == (
'{}: Template <em>content</em> with & entity'.format(service_one['name'])
)
assert ' '.join(page.find('tbody').find('tr').text.split()) == (
'07123456789 Delivered 1 January at 11:10am'
)
assert page.find('div', {'data-key': 'notifications'})['data-resource'] == url_for(
'main.view_job_updates',
service_id=service_one['id'],
job_id=fake_uuid,
status=status_argument,
)
csv_link = page.find('a', {'download': 'download'})
assert csv_link['href'] == url_for(
'main.view_job_csv',
service_id=service_one['id'],
job_id=fake_uuid,
status=status_argument
)
assert csv_link.text == 'Download this report'
assert page.find('span', {'id': 'time-left'}).text == 'Data available for 7 days'
mock_get_notifications.assert_called_with(
service_one['id'],
fake_uuid,
status=expected_api_call
)
@@ -160,7 +156,7 @@ def test_get_jobs_should_tell_user_if_more_than_one_page(
def test_should_show_job_in_progress(
app_,
logged_in_client,
service_one,
active_user_with_permissions,
mock_get_service_template,
@@ -169,22 +165,21 @@ def test_should_show_job_in_progress(
mock_get_notifications,
fake_uuid,
):
with app_.test_request_context(), app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service_one)
response = client.get(url_for(
'main.view_job',
service_id=service_one['id'],
job_id=fake_uuid
))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.find('p', {'class': 'hint'}).text.strip() == 'Report is 50% complete…'
response = logged_in_client.get(url_for(
'main.view_job',
service_id=service_one['id'],
job_id=fake_uuid
))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.find('p', {'class': 'hint'}).text.strip() == 'Report is 50% complete…'
@freeze_time("2016-01-01T00:00:00.061258")
def test_should_show_scheduled_job(
app_,
logged_in_client,
service_one,
active_user_with_permissions,
mock_get_service_template,
@@ -193,62 +188,56 @@ def test_should_show_scheduled_job(
mock_get_notifications,
fake_uuid,
):
with app_.test_request_context(), app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service_one)
response = client.get(url_for(
'main.view_job',
service_id=service_one['id'],
job_id=fake_uuid
))
response = logged_in_client.get(url_for(
'main.view_job',
service_id=service_one['id'],
job_id=fake_uuid
))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.find('main').find_all('p')[1].text.strip() == 'Sending will start today at midnight'
assert page.find('input', {'type': 'submit', 'value': 'Cancel sending'})
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.find('main').find_all('p')[1].text.strip() == 'Sending will start today at midnight'
assert page.find('input', {'type': 'submit', 'value': 'Cancel sending'})
def test_should_cancel_job(
app_,
logged_in_client,
service_one,
active_user_with_permissions,
fake_uuid,
mocker,
):
with app_.test_request_context(), app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service_one)
mock_cancel = mocker.patch('app.main.jobs.job_api_client.cancel_job')
response = client.post(url_for(
'main.cancel_job',
service_id=service_one['id'],
job_id=fake_uuid
))
mock_cancel = mocker.patch('app.main.jobs.job_api_client.cancel_job')
response = logged_in_client.post(url_for(
'main.cancel_job',
service_id=service_one['id'],
job_id=fake_uuid
))
mock_cancel.assert_called_once_with(service_one['id'], fake_uuid)
assert response.status_code == 302
assert response.location == url_for('main.service_dashboard', service_id=service_one['id'], _external=True)
mock_cancel.assert_called_once_with(service_one['id'], fake_uuid)
assert response.status_code == 302
assert response.location == url_for('main.service_dashboard', service_id=service_one['id'], _external=True)
def test_should_not_show_cancelled_job(
app_,
logged_in_client,
service_one,
active_user_with_permissions,
mock_get_cancelled_job,
mocker,
fake_uuid,
):
with app_.test_request_context(), app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service_one)
response = client.get(url_for(
'main.view_job',
service_id=service_one['id'],
job_id=fake_uuid
))
response = logged_in_client.get(url_for(
'main.view_job',
service_id=service_one['id'],
job_id=fake_uuid
))
assert response.status_code == 404
assert response.status_code == 404
def test_should_show_not_show_csv_download_in_tour(
app_,
logged_in_client,
service_one,
active_user_with_permissions,
mock_get_service_template,
@@ -257,33 +246,31 @@ def test_should_show_not_show_csv_download_in_tour(
mock_get_notifications,
fake_uuid,
):
with app_.test_request_context(), app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service_one)
response = client.get(url_for(
'main.view_job',
service_id=service_one['id'],
job_id=fake_uuid,
help=3
))
response = logged_in_client.get(url_for(
'main.view_job',
service_id=service_one['id'],
job_id=fake_uuid,
help=3
))
assert response.status_code == 200
assert url_for(
'main.view_job_updates',
service_id=service_one['id'],
job_id=fake_uuid,
status='',
help=3
).replace('&', '&amp;') in response.get_data(as_text=True)
assert url_for(
'main.view_job_csv',
service_id=service_one['id'],
job_id=fake_uuid
) not in response.get_data(as_text=True)
assert response.status_code == 200
assert url_for(
'main.view_job_updates',
service_id=service_one['id'],
job_id=fake_uuid,
status='',
help=3
).replace('&', '&amp;') in response.get_data(as_text=True)
assert url_for(
'main.view_job_csv',
service_id=service_one['id'],
job_id=fake_uuid
) not in response.get_data(as_text=True)
@freeze_time("2016-01-01 00:00:00.000001")
def test_should_show_updates_for_one_job_as_json(
app_,
logged_in_client,
service_one,
active_user_with_permissions,
mock_get_notifications,
@@ -292,22 +279,19 @@ def test_should_show_updates_for_one_job_as_json(
fake_uuid,
):
job_json = mock_get_job(service_one['id'], fake_uuid)['data']
with app_.test_request_context():
with app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service_one)
response = client.get(url_for('main.view_job_updates', service_id=service_one['id'], job_id=fake_uuid))
response = logged_in_client.get(url_for('main.view_job_updates', service_id=service_one['id'], job_id=fake_uuid))
assert response.status_code == 200
content = json.loads(response.get_data(as_text=True))
assert 'sending' in content['counts']
assert 'delivered' in content['counts']
assert 'failed' in content['counts']
assert 'Recipient' in content['notifications']
assert '07123456789' in content['notifications']
assert 'Status' in content['notifications']
assert 'Delivered' in content['notifications']
assert '12:01am' in content['notifications']
assert 'Sent by Test User on 1 January at midnight' in content['status']
assert response.status_code == 200
content = json.loads(response.get_data(as_text=True))
assert 'sending' in content['counts']
assert 'delivered' in content['counts']
assert 'failed' in content['counts']
assert 'Recipient' in content['notifications']
assert '07123456789' in content['notifications']
assert 'Status' in content['notifications']
assert 'Delivered' in content['notifications']
assert '12:01am' in content['notifications']
assert 'Sent by Test User on 1 January at midnight' in content['status']
@pytest.mark.parametrize(
@@ -400,39 +384,36 @@ def test_can_show_notifications(
def test_should_show_notifications_for_a_service_with_next_previous(
app_,
logged_in_client,
service_one,
active_user_with_permissions,
mock_get_notifications_with_previous_next,
mock_get_detailed_service,
mocker,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service_one)
response = client.get(url_for(
'main.view_notifications',
service_id=service_one['id'],
message_type='sms',
page=2
))
assert response.status_code == 200
content = response.get_data(as_text=True)
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
next_page_link = page.find('a', {'rel': 'next'})
prev_page_link = page.find('a', {'rel': 'previous'})
assert (
url_for('main.view_notifications', service_id=service_one['id'], message_type='sms', page=3) in
next_page_link['href']
)
assert 'Next page' in next_page_link.text.strip()
assert 'page 3' in next_page_link.text.strip()
assert (
url_for('main.view_notifications', service_id=service_one['id'], message_type='sms', page=1) in
prev_page_link['href']
)
assert 'Previous page' in prev_page_link.text.strip()
assert 'page 1' in prev_page_link.text.strip()
response = logged_in_client.get(url_for(
'main.view_notifications',
service_id=service_one['id'],
message_type='sms',
page=2
))
assert response.status_code == 200
content = response.get_data(as_text=True)
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
next_page_link = page.find('a', {'rel': 'next'})
prev_page_link = page.find('a', {'rel': 'previous'})
assert (
url_for('main.view_notifications', service_id=service_one['id'], message_type='sms', page=3) in
next_page_link['href']
)
assert 'Next page' in next_page_link.text.strip()
assert 'page 3' in next_page_link.text.strip()
assert (
url_for('main.view_notifications', service_id=service_one['id'], message_type='sms', page=1) in
prev_page_link['href']
)
assert 'Previous page' in prev_page_link.text.strip()
assert 'page 1' in prev_page_link.text.strip()
@pytest.mark.parametrize(
@@ -457,9 +438,8 @@ STATISTICS = {
}
def test_get_status_filters_calculates_stats(app_):
with app_.test_request_context():
ret = get_status_filters({'id': 'foo'}, 'sms', STATISTICS)
def test_get_status_filters_calculates_stats(client):
ret = get_status_filters({'id': 'foo'}, 'sms', STATISTICS)
assert {label: count for label, _option, _link, count in ret} == {
'total': 6,
@@ -469,33 +449,30 @@ def test_get_status_filters_calculates_stats(app_):
}
def test_get_status_filters_in_right_order(app_):
with app_.test_request_context():
ret = get_status_filters({'id': 'foo'}, 'sms', STATISTICS)
def test_get_status_filters_in_right_order(client):
ret = get_status_filters({'id': 'foo'}, 'sms', STATISTICS)
assert [label for label, _option, _link, _count in ret] == [
'total', 'sending', 'delivered', 'failed'
]
def test_get_status_filters_constructs_links(app_):
with app_.test_request_context():
ret = get_status_filters({'id': 'foo'}, 'sms', STATISTICS)
def test_get_status_filters_constructs_links(client):
ret = get_status_filters({'id': 'foo'}, 'sms', STATISTICS)
link = ret[0][2]
assert link == '/services/foo/notifications/sms?status={}'.format(quote('sending,delivered,failed'))
def test_html_contains_notification_id(
client,
logged_in_client,
service_one,
active_user_with_permissions,
mock_get_notifications,
mock_get_detailed_service,
mocker,
):
client.login(active_user_with_permissions, mocker, service_one)
response = client.get(url_for(
response = logged_in_client.get(url_for(
'main.view_notifications',
service_id=service_one['id'],
message_type='sms',

386
tests/app/main/views/test_manage_users.py
View File

@@ -8,77 +8,68 @@ from tests.conftest import service_one as create_sample_service
def test_should_show_overview_page(
app_,
logged_in_client,
active_user_with_permissions,
mocker,
mock_get_invites_for_service,
):
service = create_sample_service(active_user_with_permissions)
with app_.test_request_context():
with app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service)
mocker.patch('app.user_api_client.get_users_for_service', return_value=[active_user_with_permissions])
response = client.get(url_for('main.manage_users', service_id=service['id']))
mocker.patch('app.user_api_client.get_users_for_service', return_value=[active_user_with_permissions])
response = logged_in_client.get(url_for('main.manage_users', service_id=service['id']))
assert 'Team members' in response.get_data(as_text=True)
assert response.status_code == 200
app.user_api_client.get_users_for_service.assert_called_once_with(service_id=service['id'])
assert 'Team members' in response.get_data(as_text=True)
assert response.status_code == 200
app.user_api_client.get_users_for_service.assert_called_once_with(service_id=service['id'])
def test_should_show_page_for_one_user(
app_,
logged_in_client,
active_user_with_permissions,
mocker,
):
service = create_sample_service(active_user_with_permissions)
with app_.test_request_context():
with app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service)
response = client.get(url_for('main.edit_user_permissions', service_id=service['id'], user_id=0))
response = logged_in_client.get(url_for('main.edit_user_permissions', service_id=service['id'], user_id=0))
assert response.status_code == 200
assert response.status_code == 200
def test_edit_user_permissions(
app_,
logged_in_client,
active_user_with_permissions,
mocker,
mock_get_invites_for_service,
mock_set_user_permissions,
):
service = create_sample_service(active_user_with_permissions)
with app_.test_request_context():
with app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service)
response = client.post(url_for(
'main.edit_user_permissions', service_id=service['id'], user_id=active_user_with_permissions.id
), data={'email_address': active_user_with_permissions.email_address,
'send_messages': 'y',
'manage_service': 'y',
'manage_api_keys': 'y'})
response = logged_in_client.post(url_for(
'main.edit_user_permissions', service_id=service['id'], user_id=active_user_with_permissions.id
), data={'email_address': active_user_with_permissions.email_address,
'send_messages': 'y',
'manage_service': 'y',
'manage_api_keys': 'y'})
assert response.status_code == 302
assert response.location == url_for(
'main.manage_users', service_id=service['id'], _external=True
)
mock_set_user_permissions.assert_called_with(
str(active_user_with_permissions.id),
service['id'],
permissions={
'send_texts',
'send_emails',
'send_letters',
'manage_users',
'manage_templates',
'manage_settings',
'manage_api_keys',
'view_activity'
}
)
assert response.status_code == 302
assert response.location == url_for(
'main.manage_users', service_id=service['id'], _external=True
)
mock_set_user_permissions.assert_called_with(
str(active_user_with_permissions.id),
service['id'],
permissions={
'send_texts',
'send_emails',
'send_letters',
'manage_users',
'manage_templates',
'manage_settings',
'manage_api_keys',
'view_activity'
}
)
def test_edit_some_user_permissions(
app_,
logged_in_client,
mocker,
active_user_with_permissions,
sample_invite,
@@ -87,48 +78,43 @@ def test_edit_some_user_permissions(
):
service = create_sample_service(active_user_with_permissions)
data = [InvitedUser(**sample_invite)]
with app_.test_request_context():
with app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service)
service_id = service['id']
mocker.patch('app.invite_api_client.get_invites_for_service', return_value=data)
response = client.post(url_for(
'main.edit_user_permissions', service_id=service_id, user_id=active_user_with_permissions.id
), data={'email_address': active_user_with_permissions.email_address,
'send_messages': 'y',
'manage_service': '',
'manage_api_keys': ''})
service_id = service['id']
assert response.status_code == 302
assert response.location == url_for(
'main.manage_users', service_id=service_id, _external=True
)
mock_set_user_permissions.assert_called_with(
str(active_user_with_permissions.id),
service_id,
permissions={
'send_texts',
'send_emails',
'send_letters',
'view_activity'
}
)
mocker.patch('app.invite_api_client.get_invites_for_service', return_value=data)
response = logged_in_client.post(url_for(
'main.edit_user_permissions', service_id=service_id, user_id=active_user_with_permissions.id
), data={'email_address': active_user_with_permissions.email_address,
'send_messages': 'y',
'manage_service': '',
'manage_api_keys': ''})
assert response.status_code == 302
assert response.location == url_for(
'main.manage_users', service_id=service_id, _external=True
)
mock_set_user_permissions.assert_called_with(
str(active_user_with_permissions.id),
service_id,
permissions={
'send_texts',
'send_emails',
'send_letters',
'view_activity'
}
)
def test_should_show_page_for_inviting_user(
app_,
logged_in_client,
active_user_with_permissions,
mocker,
):
service = create_sample_service(active_user_with_permissions)
with app_.test_request_context():
with app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service)
response = client.get(url_for('main.invite_user', service_id=service['id']))
response = logged_in_client.get(url_for('main.invite_user', service_id=service['id']))
assert 'Invite a team member' in response.get_data(as_text=True)
assert response.status_code == 200
assert 'Invite a team member' in response.get_data(as_text=True)
assert response.status_code == 200
@pytest.mark.parametrize('email_address, gov_user', [
@@ -136,7 +122,7 @@ def test_should_show_page_for_inviting_user(
('test@nonwhitelist.com', False)
])
def test_invite_user(
app_,
logged_in_client,
active_user_with_permissions,
mocker,
sample_invite,
@@ -147,82 +133,73 @@ def test_invite_user(
sample_invite['email_address'] = 'test@example.gov.uk'
data = [InvitedUser(**sample_invite)]
with app_.test_request_context():
with app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service)
assert is_gov_user(email_address) == gov_user
mocker.patch('app.invite_api_client.get_invites_for_service', return_value=data)
mocker.patch('app.user_api_client.get_users_for_service', return_value=[active_user_with_permissions])
mocker.patch('app.invite_api_client.create_invite', return_value=InvitedUser(**sample_invite))
response = client.post(
url_for('main.invite_user', service_id=service['id']),
data={'email_address': email_address,
'send_messages': 'y',
'manage_service': 'y',
'manage_api_keys': 'y'},
follow_redirects=True
)
assert is_gov_user(email_address) == gov_user
mocker.patch('app.invite_api_client.get_invites_for_service', return_value=data)
mocker.patch('app.user_api_client.get_users_for_service', return_value=[active_user_with_permissions])
mocker.patch('app.invite_api_client.create_invite', return_value=InvitedUser(**sample_invite))
response = logged_in_client.post(
url_for('main.invite_user', service_id=service['id']),
data={'email_address': email_address,
'send_messages': 'y',
'manage_service': 'y',
'manage_api_keys': 'y'},
follow_redirects=True
)
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'Team members'
flash_banner = page.find('div', class_='banner-default-with-tick').string.strip()
assert flash_banner == 'Invite sent to test@example.gov.uk'
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'Team members'
flash_banner = page.find('div', class_='banner-default-with-tick').string.strip()
assert flash_banner == 'Invite sent to test@example.gov.uk'
expected_permissions = 'manage_api_keys,manage_settings,manage_templates,manage_users,send_emails,send_letters,send_texts,view_activity' # noqa
expected_permissions = 'manage_api_keys,manage_settings,manage_templates,manage_users,send_emails,send_letters,send_texts,view_activity' # noqa
app.invite_api_client.create_invite.assert_called_once_with(sample_invite['from_user'],
sample_invite['service'],
email_address,
expected_permissions)
app.invite_api_client.create_invite.assert_called_once_with(sample_invite['from_user'],
sample_invite['service'],
email_address,
expected_permissions)
def test_cancel_invited_user_cancels_user_invitations(
app_,
logged_in_client,
active_user_with_permissions,
mocker,
):
with app_.test_request_context():
with app_.test_client() as client:
mocker.patch('app.invite_api_client.cancel_invited_user')
import uuid
invited_user_id = uuid.uuid4()
service = create_sample_service(active_user_with_permissions)
client.login(active_user_with_permissions, mocker, service)
response = client.get(url_for('main.cancel_invited_user', service_id=service['id'],
invited_user_id=invited_user_id))
mocker.patch('app.invite_api_client.cancel_invited_user')
import uuid
invited_user_id = uuid.uuid4()
service = create_sample_service(active_user_with_permissions)
response = logged_in_client.get(url_for('main.cancel_invited_user', service_id=service['id'],
invited_user_id=invited_user_id))
assert response.status_code == 302
assert response.location == url_for('main.manage_users', service_id=service['id'], _external=True)
assert response.status_code == 302
assert response.location == url_for('main.manage_users', service_id=service['id'], _external=True)
def test_manage_users_shows_invited_user(
app_,
logged_in_client,
mocker,
active_user_with_permissions,
sample_invite,
):
service = create_sample_service(active_user_with_permissions)
data = [InvitedUser(**sample_invite)]
with app_.test_request_context():
with app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service)
mocker.patch('app.invite_api_client.get_invites_for_service', return_value=data)
mocker.patch('app.user_api_client.get_users_for_service', return_value=[active_user_with_permissions])
mocker.patch('app.invite_api_client.get_invites_for_service', return_value=data)
mocker.patch('app.user_api_client.get_users_for_service', return_value=[active_user_with_permissions])
response = client.get(url_for('main.manage_users', service_id=service['id']))
response = logged_in_client.get(url_for('main.manage_users', service_id=service['id']))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'Team members'
invited_users_list = page.find_all('div', {'class': 'user-list'})[1]
assert invited_users_list.find_all('h3')[0].text.strip() == 'invited_user@test.gov.uk'
assert invited_users_list.find_all('a')[0].text.strip() == 'Cancel invitation'
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'Team members'
invited_users_list = page.find_all('div', {'class': 'user-list'})[1]
assert invited_users_list.find_all('h3')[0].text.strip() == 'invited_user@test.gov.uk'
assert invited_users_list.find_all('a')[0].text.strip() == 'Cancel invitation'
def test_manage_users_does_not_show_accepted_invite(
app_,
logged_in_client,
mocker,
active_user_with_permissions,
sample_invite,
@@ -233,86 +210,74 @@ def test_manage_users_does_not_show_accepted_invite(
sample_invite['status'] = 'accepted'
data = [InvitedUser(**sample_invite)]
service = create_sample_service(active_user_with_permissions)
with app_.test_request_context():
with app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service)
mocker.patch('app.user_api_client.get_users_for_service', return_value=[active_user_with_permissions])
mocker.patch('app.invite_api_client.get_invites_for_service', return_value=data)
mocker.patch('app.user_api_client.get_users_for_service', return_value=[active_user_with_permissions])
mocker.patch('app.invite_api_client.get_invites_for_service', return_value=data)
response = client.get(url_for('main.manage_users', service_id=service['id']))
response = logged_in_client.get(url_for('main.manage_users', service_id=service['id']))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'Team members'
user_lists = page.find_all('div', {'class': 'user-list'})
assert len(user_lists) == 1
assert not page.find(text='invited_user@test.gov.uk')
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'Team members'
user_lists = page.find_all('div', {'class': 'user-list'})
assert len(user_lists) == 1
assert not page.find(text='invited_user@test.gov.uk')
def test_user_cant_invite_themselves(
app_,
logged_in_client,
mocker,
active_user_with_permissions,
mock_create_invite,
):
service = create_sample_service(active_user_with_permissions)
with app_.test_request_context():
with app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service)
response = client.post(
url_for('main.invite_user', service_id=service['id']),
data={'email_address': active_user_with_permissions.email_address,
'send_messages': 'y',
'manage_service': 'y',
'manage_api_keys': 'y'},
follow_redirects=True
)
response = logged_in_client.post(
url_for('main.invite_user', service_id=service['id']),
data={'email_address': active_user_with_permissions.email_address,
'send_messages': 'y',
'manage_service': 'y',
'manage_api_keys': 'y'},
follow_redirects=True
)
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'Invite a team member'
form_error = page.find('span', class_='error-message').string.strip()
assert form_error == "You can’t send an invitation to yourself"
assert not mock_create_invite.called
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == 'Invite a team member'
form_error = page.find('span', class_='error-message').string.strip()
assert form_error == "You can’t send an invitation to yourself"
assert not mock_create_invite.called
def test_no_permission_manage_users_page(
app_,
logged_in_client,
service_one,
api_user_active,
mocker,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active, mocker, service_one)
response = client.get(url_for('main.manage_users', service_id=service_one['id']))
resp_text = response.get_data(as_text=True)
assert url_for('.invite_user', service_id=service_one['id']) not in resp_text
assert "Edit permission" not in resp_text
assert "Team members" not in resp_text
response = logged_in_client.get(url_for('main.manage_users', service_id=service_one['id']))
resp_text = response.get_data(as_text=True)
assert url_for('.invite_user', service_id=service_one['id']) not in resp_text
assert "Edit permission" not in resp_text
assert "Team members" not in resp_text
def test_get_remove_user_from_service(
app_,
logged_in_client,
active_user_with_permissions,
service_one,
mocker,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service_one)
response = client.get(
url_for(
'main.remove_user_from_service',
service_id=service_one['id'],
user_id=active_user_with_permissions.id))
assert response.status_code == 200
assert "Are you sure you want to remove" in response.get_data(as_text=True)
assert "Remove user from service" in response.get_data(as_text=True)
response = logged_in_client.get(
url_for(
'main.remove_user_from_service',
service_id=service_one['id'],
user_id=active_user_with_permissions.id))
assert response.status_code == 200
assert "Are you sure you want to remove" in response.get_data(as_text=True)
assert "Remove user from service" in response.get_data(as_text=True)
def test_remove_user_from_service(
app_,
logged_in_client,
active_user_with_permissions,
service_one,
mocker,
@@ -320,57 +285,48 @@ def test_remove_user_from_service(
mock_get_user,
mock_remove_user_from_service,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service_one)
response = client.post(
url_for(
'main.remove_user_from_service',
service_id=service_one['id'],
user_id=active_user_with_permissions.id))
assert response.status_code == 302
assert response.location == url_for(
'main.manage_users', service_id=service_one['id'], _external=True)
mock_remove_user_from_service.assert_called_once_with(service_one['id'],
str(active_user_with_permissions.id))
response = logged_in_client.post(
url_for(
'main.remove_user_from_service',
service_id=service_one['id'],
user_id=active_user_with_permissions.id))
assert response.status_code == 302
assert response.location == url_for(
'main.manage_users', service_id=service_one['id'], _external=True)
mock_remove_user_from_service.assert_called_once_with(service_one['id'],
str(active_user_with_permissions.id))
def test_can_remove_user_from_service_as_platform_admin(
app_,
logged_in_client,
service_one,
platform_admin_user,
active_user_with_permissions,
mock_remove_user_from_service,
mocker,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(platform_admin_user, mocker, service_one)
response = client.post(
url_for(
'main.remove_user_from_service',
service_id=service_one['id'],
user_id=active_user_with_permissions.id))
assert response.status_code == 302
assert response.location == url_for(
'main.manage_users', service_id=service_one['id'], _external=True)
mock_remove_user_from_service.assert_called_once_with(service_one['id'],
str(active_user_with_permissions.id))
response = logged_in_client.post(
url_for(
'main.remove_user_from_service',
service_id=service_one['id'],
user_id=active_user_with_permissions.id))
assert response.status_code == 302
assert response.location == url_for(
'main.manage_users', service_id=service_one['id'], _external=True)
mock_remove_user_from_service.assert_called_once_with(service_one['id'],
str(active_user_with_permissions.id))
def test_can_invite_user_as_platform_admin(
app_,
logged_in_client,
service_one,
platform_admin_user,
active_user_with_permissions,
mock_get_invites_for_service,
mocker,
):
with app_.test_request_context():
with app_.test_client() as client:
mocker.patch('app.user_api_client.get_users_for_service', return_value=[active_user_with_permissions])
mocker.patch('app.user_api_client.get_users_for_service', return_value=[active_user_with_permissions])
client.login(platform_admin_user, mocker, service_one)
response = client.get(url_for('main.manage_users', service_id=service_one['id']))
resp_text = response.get_data(as_text=True)
assert url_for('.invite_user', service_id=service_one['id']) in resp_text
response = logged_in_client.get(url_for('main.manage_users', service_id=service_one['id']))
resp_text = response.get_data(as_text=True)
assert url_for('.invite_user', service_id=service_one['id']) in resp_text

77
tests/app/main/views/test_new_password.py
View File

@@ -7,78 +7,73 @@ from notifications_utils.url_safe_token import generate_token
def test_should_render_new_password_template(
app_,
client,
api_user_active,
mock_login,
mock_send_verify_code,
mock_get_user_by_email_request_password_reset,
):
with app_.test_request_context():
with app_.test_client() as client:
data = json.dumps({'email': api_user_active.email_address, 'created_at': str(datetime.utcnow())})
token = generate_token(data, app_.config['SECRET_KEY'],
app_.config['DANGEROUS_SALT'])
response = client.get(url_for('.new_password', token=token))
assert response.status_code == 200
assert 'You can now create a new password for your account.' in response.get_data(as_text=True)
data = json.dumps({'email': api_user_active.email_address, 'created_at': str(datetime.utcnow())})
token = generate_token(data, app_.config['SECRET_KEY'],
app_.config['DANGEROUS_SALT'])
response = client.get(url_for('.new_password', token=token))
assert response.status_code == 200
assert 'You can now create a new password for your account.' in response.get_data(as_text=True)
def test_should_return_404_when_email_address_does_not_exist(
app_,
client,
mock_get_user_by_email_not_found,
):
with app_.test_request_context():
with app_.test_client() as client:
data = json.dumps({'email': 'no_user@d.gov.uk', 'created_at': str(datetime.utcnow())})
token = generate_token(data, app_.config['SECRET_KEY'], app_.config['DANGEROUS_SALT'])
response = client.get(url_for('.new_password', token=token))
assert response.status_code == 404
data = json.dumps({'email': 'no_user@d.gov.uk', 'created_at': str(datetime.utcnow())})
token = generate_token(data, app_.config['SECRET_KEY'], app_.config['DANGEROUS_SALT'])
response = client.get(url_for('.new_password', token=token))
assert response.status_code == 404
def test_should_redirect_to_two_factor_when_password_reset_is_successful(
app_,
client,
mock_get_user_by_email_request_password_reset,
mock_login,
mock_send_verify_code,
):
with app_.test_request_context():
with app_.test_client() as client:
user = mock_get_user_by_email_request_password_reset.return_value
data = json.dumps({'email': user.email_address, 'created_at': str(datetime.utcnow())})
token = generate_token(data, app_.config['SECRET_KEY'], app_.config['DANGEROUS_SALT'])
response = client.post(url_for('.new_password', token=token), data={'new_password': 'a-new_password'})
assert response.status_code == 302
assert response.location == url_for('.two_factor', _external=True)
mock_get_user_by_email_request_password_reset.assert_called_once_with(user.email_address)
user = mock_get_user_by_email_request_password_reset.return_value
data = json.dumps({'email': user.email_address, 'created_at': str(datetime.utcnow())})
token = generate_token(data, app_.config['SECRET_KEY'], app_.config['DANGEROUS_SALT'])
response = client.post(url_for('.new_password', token=token), data={'new_password': 'a-new_password'})
assert response.status_code == 302
assert response.location == url_for('.two_factor', _external=True)
mock_get_user_by_email_request_password_reset.assert_called_once_with(user.email_address)
def test_should_redirect_index_if_user_has_already_changed_password(
app_,
client,
mock_get_user_by_email_user_changed_password,
mock_login,
mock_send_verify_code,
):
with app_.test_request_context():
with app_.test_client() as client:
user = mock_get_user_by_email_user_changed_password.return_value
data = json.dumps({'email': user.email_address, 'created_at': str(datetime.utcnow())})
token = generate_token(data, app_.config['SECRET_KEY'], app_.config['DANGEROUS_SALT'])
response = client.post(url_for('.new_password', token=token), data={'new_password': 'a-new_password'})
assert response.status_code == 302
assert response.location == url_for('.index', _external=True)
mock_get_user_by_email_user_changed_password.assert_called_once_with(user.email_address)
user = mock_get_user_by_email_user_changed_password.return_value
data = json.dumps({'email': user.email_address, 'created_at': str(datetime.utcnow())})
token = generate_token(data, app_.config['SECRET_KEY'], app_.config['DANGEROUS_SALT'])
response = client.post(url_for('.new_password', token=token), data={'new_password': 'a-new_password'})
assert response.status_code == 302
assert response.location == url_for('.index', _external=True)
mock_get_user_by_email_user_changed_password.assert_called_once_with(user.email_address)
def test_should_redirect_to_forgot_password_with_flash_message_when_token_is_expired(
app_,
client,
mock_get_user_by_email_request_password_reset,
mock_login,
):
with app_.test_request_context():
with app_.test_client() as client:
app_.config['TOKEN_MAX_AGE_SECONDS'] = -1000
user = mock_get_user_by_email_request_password_reset.return_value
token = generate_token(user.email_address, app_.config['SECRET_KEY'], app_.config['DANGEROUS_SALT'])
response = client.post(url_for('.new_password', token=token), data={'new_password': 'a-new_password'})
assert response.status_code == 302
assert response.location == url_for('.forgot_password', _external=True)
app_.config['TOKEN_MAX_AGE_SECONDS'] = 3600
app_.config['TOKEN_MAX_AGE_SECONDS'] = -1000
user = mock_get_user_by_email_request_password_reset.return_value
token = generate_token(user.email_address, app_.config['SECRET_KEY'], app_.config['DANGEROUS_SALT'])
response = client.post(url_for('.new_password', token=token), data={'new_password': 'a-new_password'})
assert response.status_code == 302
assert response.location == url_for('.forgot_password', _external=True)
app_.config['TOKEN_MAX_AGE_SECONDS'] = 3600

73
tests/app/main/views/test_platform_admin.py
View File

@@ -11,28 +11,23 @@ from app.main.views.platform_admin import format_stats_by_service, create_global
def test_should_redirect_if_not_logged_in(
app_
client
):
with app_.test_request_context():
with app_.test_client() as client:
response = client.get(url_for('main.platform_admin'))
assert response.status_code == 302
assert url_for('main.index', _external=True) in response.location
response = client.get(url_for('main.platform_admin'))
assert response.status_code == 302
assert url_for('main.index', _external=True) in response.location
def test_should_403_if_not_platform_admin(
app_,
client,
active_user_with_permissions,
mocker,
):
with app_.test_request_context():
with app_.test_client() as client:
mock_get_user(mocker, user=active_user_with_permissions)
client.login(active_user_with_permissions)
mock_get_user(mocker, user=active_user_with_permissions)
client.login(active_user_with_permissions)
response = client.get(url_for('main.platform_admin'))
response = client.get(url_for('main.platform_admin'))
assert response.status_code == 403
assert response.status_code == 403
@pytest.mark.parametrize('restricted, table_index, research_mode, displayed', [
@@ -46,7 +41,7 @@ def test_should_show_research_and_restricted_mode(
table_index,
research_mode,
displayed,
app_,
client,
platform_admin_user,
mocker,
mock_get_detailed_services,
@@ -56,11 +51,9 @@ def test_should_show_research_and_restricted_mode(
services[0]['statistics'] = create_stats()
mock_get_detailed_services.return_value = {'data': services}
with app_.test_request_context():
with app_.test_client() as client:
mock_get_user(mocker, user=platform_admin_user)
client.login(platform_admin_user)
response = client.get(url_for('main.platform_admin'))
mock_get_user(mocker, user=platform_admin_user)
client.login(platform_admin_user)
response = client.get(url_for('main.platform_admin'))
assert response.status_code == 200
mock_get_detailed_services.assert_called_once_with({'detailed': True, 'include_from_test_key': True})
@@ -72,16 +65,14 @@ def test_should_show_research_and_restricted_mode(
def test_should_render_platform_admin_page(
app_,
client,
platform_admin_user,
mocker,
mock_get_detailed_services,
):
with app_.test_request_context():
with app_.test_client() as client:
mock_get_user(mocker, user=platform_admin_user)
client.login(platform_admin_user)
response = client.get(url_for('main.platform_admin'))
mock_get_user(mocker, user=platform_admin_user)
client.login(platform_admin_user)
response = client.get(url_for('main.platform_admin'))
assert response.status_code == 200
resp_data = response.get_data(as_text=True)
@@ -98,32 +89,28 @@ def test_should_render_platform_admin_page(
def test_platform_admin_toggle_including_from_test_key(
include_from_test_key,
api_args,
app_,
client,
platform_admin_user,
mocker,
mock_get_detailed_services,
):
with app_.test_request_context():
with app_.test_client() as client:
mock_get_user(mocker, user=platform_admin_user)
client.login(platform_admin_user)
response = client.get(url_for('main.platform_admin', include_from_test_key=include_from_test_key))
mock_get_user(mocker, user=platform_admin_user)
client.login(platform_admin_user)
response = client.get(url_for('main.platform_admin', include_from_test_key=include_from_test_key))
assert response.status_code == 200
mock_get_detailed_services.assert_called_once_with(api_args)
def test_platform_admin_with_date_filter(
app_,
client,
platform_admin_user,
mocker,
mock_get_detailed_services,
):
with app_.test_request_context():
with app_.test_client() as client:
mock_get_user(mocker, user=platform_admin_user)
client.login(platform_admin_user)
response = client.get(url_for('main.platform_admin', start_date='2016-12-20', end_date='2016-12-28'))
mock_get_user(mocker, user=platform_admin_user)
client.login(platform_admin_user)
response = client.get(url_for('main.platform_admin', start_date='2016-12-20', end_date='2016-12-28'))
assert response.status_code == 200
resp_data = response.get_data(as_text=True)
@@ -224,7 +211,7 @@ def test_should_show_email_and_sms_stats_for_all_service_types(
restricted,
table_index,
research_mode,
app_,
client,
platform_admin_user,
mocker,
mock_get_detailed_services,
@@ -241,11 +228,9 @@ def test_should_show_email_and_sms_stats_for_all_service_types(
)
mock_get_detailed_services.return_value = {'data': services}
with app_.test_request_context():
with app_.test_client() as client:
mock_get_user(mocker, user=platform_admin_user)
client.login(platform_admin_user)
response = client.get(url_for('main.platform_admin'))
mock_get_user(mocker, user=platform_admin_user)
client.login(platform_admin_user)
response = client.get(url_for('main.platform_admin'))
assert response.status_code == 200
mock_get_detailed_services.assert_called_once_with({'detailed': True, 'include_from_test_key': True})

192
tests/app/main/views/test_providers.py
View File

@@ -63,7 +63,7 @@ stub_provider = {
def test_should_show_all_providers(
app_,
client,
platform_admin_user,
mocker,
):
@@ -72,65 +72,63 @@ def test_should_show_all_providers(
return_value=copy.deepcopy(stub_providers)
)
with app_.test_request_context():
with app_.test_client() as client:
client.login(platform_admin_user, mocker)
response = client.get(url_for('main.view_providers'))
client.login(platform_admin_user, mocker)
response = client.get(url_for('main.view_providers'))
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
h1 = [header.text.strip() for header in page.find_all('h1')]
h1 = [header.text.strip() for header in page.find_all('h1')]
assert 'Providers' in h1
assert 'Providers' in h1
h2 = [header.text.strip() for header in page.find_all('h2')]
h2 = [header.text.strip() for header in page.find_all('h2')]
assert 'Email' in h2
assert 'SMS' in h2
assert 'Email' in h2
assert 'SMS' in h2
tables = page.find_all('table')
assert len(tables) == 2
tables = page.find_all('table')
assert len(tables) == 2
sms_table = tables[0]
email_table = tables[1]
sms_table = tables[0]
email_table = tables[1]
sms_first_row = sms_table.tbody.find_all('tr')[0]
table_data = sms_first_row.find_all('td')
sms_first_row = sms_table.tbody.find_all('tr')[0]
table_data = sms_first_row.find_all('td')
assert table_data[0].text.strip() == "first_sms_provider"
assert table_data[1].text.strip() == "1"
assert table_data[2].text.strip() == "True"
assert table_data[3].text.strip() == "16 January at 3:20pm"
assert table_data[4].find_all("a")[0]['href'] == '/provider/6005e192-4738-4962-beec-ebd982d0b03f'
assert table_data[0].text.strip() == "first_sms_provider"
assert table_data[1].text.strip() == "1"
assert table_data[2].text.strip() == "True"
assert table_data[3].text.strip() == "16 January at 3:20pm"
assert table_data[4].find_all("a")[0]['href'] == '/provider/6005e192-4738-4962-beec-ebd982d0b03f'
sms_second_row = sms_table.tbody.find_all('tr')[1]
table_data = sms_second_row.find_all('td')
sms_second_row = sms_table.tbody.find_all('tr')[1]
table_data = sms_second_row.find_all('td')
assert table_data[0].text.strip() == "second_sms_provider"
assert table_data[1].text.strip() == "2"
assert table_data[2].text.strip() == "True"
assert table_data[3].text.strip() == "None"
assert table_data[4].find_all("a")[0]['href'] == '/provider/0bd529cd-a0fd-43e5-80ee-b95ef6b0d51f'
assert table_data[0].text.strip() == "second_sms_provider"
assert table_data[1].text.strip() == "2"
assert table_data[2].text.strip() == "True"
assert table_data[3].text.strip() == "None"
assert table_data[4].find_all("a")[0]['href'] == '/provider/0bd529cd-a0fd-43e5-80ee-b95ef6b0d51f'
email_first_row = email_table.tbody.find_all('tr')[0]
email_table_data = email_first_row.find_all('td')
email_first_row = email_table.tbody.find_all('tr')[0]
email_table_data = email_first_row.find_all('td')
assert email_table_data[0].text.strip() == "first_email_provider"
assert email_table_data[1].text.strip() == "1"
assert email_table_data[2].text.strip() == "True"
assert email_table_data[3].find_all("a")[0]['href'] == '/provider/6005e192-4738-4962-beec-ebd982d0b03a'
assert email_table_data[0].text.strip() == "first_email_provider"
assert email_table_data[1].text.strip() == "1"
assert email_table_data[2].text.strip() == "True"
assert email_table_data[3].find_all("a")[0]['href'] == '/provider/6005e192-4738-4962-beec-ebd982d0b03a'
email_second_row = email_table.tbody.find_all('tr')[1]
email_table_data = email_second_row.find_all('td')
email_second_row = email_table.tbody.find_all('tr')[1]
email_table_data = email_second_row.find_all('td')
assert email_table_data[0].text.strip() == "second_email_provider"
assert email_table_data[1].text.strip() == "2"
assert email_table_data[2].text.strip() == "True"
assert email_table_data[3].find_all("a")[0]['href'] == '/provider/0bd529cd-a0fd-43e5-80ee-b95ef6b0d51b'
assert email_table_data[0].text.strip() == "second_email_provider"
assert email_table_data[1].text.strip() == "2"
assert email_table_data[2].text.strip() == "True"
assert email_table_data[3].find_all("a")[0]['href'] == '/provider/0bd529cd-a0fd-43e5-80ee-b95ef6b0d51b'
def test_should_show_provider_detail(
app_,
client,
platform_admin_user,
mocker,
):
@@ -139,26 +137,24 @@ def test_should_show_provider_detail(
return_value=copy.deepcopy(stub_provider)
)
with app_.test_request_context():
with app_.test_client() as client:
client.login(platform_admin_user, mocker)
response = client.get(url_for('main.view_provider', provider_id='12345'))
client.login(platform_admin_user, mocker)
response = client.get(url_for('main.view_provider', provider_id='12345'))
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
h1 = [header.text.strip() for header in page.find_all('h1')]
h1 = [header.text.strip() for header in page.find_all('h1')]
assert 'first_sms_provider' in h1
assert 'first_sms_provider' in h1
form = [form for form in page.find_all('form')]
form = [form for form in page.find_all('form')]
form_elements = [element for element in form[0].find_all('input')]
assert form_elements[0]['value'] == '1'
assert form_elements[0]['name'] == 'priority'
form_elements = [element for element in form[0].find_all('input')]
assert form_elements[0]['value'] == '1'
assert form_elements[0]['name'] == 'priority'
def test_should_show_error_on_bad_provider_priority(
app_,
client,
platform_admin_user,
mocker,
):
@@ -167,20 +163,18 @@ def test_should_show_error_on_bad_provider_priority(
return_value=copy.deepcopy(stub_provider)
)
with app_.test_request_context():
with app_.test_client() as client:
client.login(platform_admin_user, mocker)
response = client.post(
url_for('main.view_provider', provider_id=stub_provider['provider_details']['id']),
data={'priority': "not valid"})
client.login(platform_admin_user, mocker)
response = client.post(
url_for('main.view_provider', provider_id=stub_provider['provider_details']['id']),
data={'priority': "not valid"})
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert response.status_code == 200
assert "Not a valid integer value" in str(page.find_all("span", {"class": re.compile(r"error-message")})[0])
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert response.status_code == 200
assert "Not a valid integer value" in str(page.find_all("span", {"class": re.compile(r"error-message")})[0])
def test_should_show_error_on_negative_provider_priority(
app_,
client,
platform_admin_user,
mocker,
):
@@ -189,20 +183,18 @@ def test_should_show_error_on_negative_provider_priority(
return_value=copy.deepcopy(stub_provider)
)
with app_.test_request_context():
with app_.test_client() as client:
client.login(platform_admin_user, mocker)
response = client.post(
url_for('main.view_provider', provider_id=stub_provider['provider_details']['id']),
data={'priority': -1})
client.login(platform_admin_user, mocker)
response = client.post(
url_for('main.view_provider', provider_id=stub_provider['provider_details']['id']),
data={'priority': -1})
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert response.status_code == 200
assert "Must be between 1 and 100" in str(page.find_all("span", {"class": re.compile(r"error-message")})[0])
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert response.status_code == 200
assert "Must be between 1 and 100" in str(page.find_all("span", {"class": re.compile(r"error-message")})[0])
def test_should_show_error_on_too_big_provider_priority(
app_,
client,
platform_admin_user,
mocker,
):
@@ -211,20 +203,18 @@ def test_should_show_error_on_too_big_provider_priority(
return_value=copy.deepcopy(stub_provider)
)
with app_.test_request_context():
with app_.test_client() as client:
client.login(platform_admin_user, mocker)
response = client.post(
url_for('main.view_provider', provider_id=stub_provider['provider_details']['id']),
data={'priority': 101})
client.login(platform_admin_user, mocker)
response = client.post(
url_for('main.view_provider', provider_id=stub_provider['provider_details']['id']),
data={'priority': 101})
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert response.status_code == 200
assert "Must be between 1 and 100" in str(page.find_all("span", {"class": re.compile(r"error-message")})[0])
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert response.status_code == 200
assert "Must be between 1 and 100" in str(page.find_all("span", {"class": re.compile(r"error-message")})[0])
def test_should_show_error_on_too_little_provider_priority(
app_,
client,
platform_admin_user,
mocker,
):
@@ -233,20 +223,18 @@ def test_should_show_error_on_too_little_provider_priority(
return_value=copy.deepcopy(stub_provider)
)
with app_.test_request_context():
with app_.test_client() as client:
client.login(platform_admin_user, mocker)
response = client.post(
url_for('main.view_provider', provider_id=stub_provider['provider_details']['id']),
data={'priority': 0})
client.login(platform_admin_user, mocker)
response = client.post(
url_for('main.view_provider', provider_id=stub_provider['provider_details']['id']),
data={'priority': 0})
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert response.status_code == 200
assert "Must be between 1 and 100" in str(page.find_all("span", {"class": re.compile(r"error-message")})[0])
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert response.status_code == 200
assert "Must be between 1 and 100" in str(page.find_all("span", {"class": re.compile(r"error-message")})[0])
def test_should_update_provider_priority(
app_,
client,
platform_admin_user,
mocker,
):
@@ -261,13 +249,11 @@ def test_should_update_provider_priority(
return_value=copy.deepcopy(stub_provider)
)
with app_.test_request_context():
with app_.test_client() as client:
client.login(platform_admin_user, mocker)
response = client.post(
url_for('main.view_provider', provider_id=stub_provider['provider_details']['id']),
data={'priority': 2})
client.login(platform_admin_user, mocker)
response = client.post(
url_for('main.view_provider', provider_id=stub_provider['provider_details']['id']),
data={'priority': 2})
app.provider_client.update_provider.assert_called_with(stub_provider['provider_details']['id'], 2)
assert response.status_code == 302
assert response.location == 'http://localhost/providers'
app.provider_client.update_provider.assert_called_with(stub_provider['provider_details']['id'], 2)
assert response.status_code == 302
assert response.location == 'http://localhost/providers'

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

@@ -15,17 +15,16 @@ def test_render_register_returns_template_with_form(client):
def test_logged_in_user_redirects_to_choose_service(
client,
logged_in_client,
api_user_active,
mock_get_user_by_email,
mock_send_verify_code,
mock_login,
):
client.login(api_user_active)
response = client.get(url_for('main.register'))
response = logged_in_client.get(url_for('main.register'))
assert response.status_code == 302
response = client.get(url_for('main.sign_in', follow_redirects=True))
response = logged_in_client.get(url_for('main.sign_in', follow_redirects=True))
assert response.location == url_for('main.choose_service', _external=True)

611
tests/app/main/views/test_send.py
View File

@@ -39,7 +39,7 @@ def test_that_test_files_exist():
def test_upload_files_in_different_formats(
filename,
acceptable_file,
app_,
logged_in_client,
api_user_active,
mocker,
mock_login,
@@ -50,9 +50,8 @@ def test_upload_files_in_different_formats(
fake_uuid,
):
with app_.test_request_context(), app_.test_client() as client, open(filename, 'rb') as uploaded:
client.login(api_user_active)
response = client.post(
with open(filename, 'rb') as uploaded:
response = logged_in_client.post(
url_for('main.send_messages', service_id=fake_uuid, template_id=fake_uuid),
data={'file': (BytesIO(uploaded.read()), filename)},
content_type='multipart/form-data'
@@ -73,7 +72,7 @@ def test_upload_files_in_different_formats(
def test_upload_csvfile_with_errors_shows_check_page_with_errors(
app_,
logged_in_client,
api_user_active,
mocker,
mock_login,
@@ -95,32 +94,29 @@ def test_upload_csvfile_with_errors_shows_check_page_with_errors(
"""
)
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
initial_upload = client.post(
url_for('main.send_messages', service_id=fake_uuid, template_id=fake_uuid),
data={'file': (BytesIO(''.encode('utf-8')), 'invalid.csv')},
content_type='multipart/form-data',
follow_redirects=True
)
reupload = client.post(
url_for('main.check_messages', service_id=fake_uuid, template_type='sms', upload_id='abc123'),
data={'file': (BytesIO(''.encode('utf-8')), 'invalid.csv')},
content_type='multipart/form-data',
follow_redirects=True
)
for response in [initial_upload, reupload]:
assert response.status_code == 200
content = response.get_data(as_text=True)
assert 'There is a problem with your data' in content
assert '+447700900986' in content
assert 'Missing' in content
assert 'Re-upload your file' in content
initial_upload = logged_in_client.post(
url_for('main.send_messages', service_id=fake_uuid, template_id=fake_uuid),
data={'file': (BytesIO(''.encode('utf-8')), 'invalid.csv')},
content_type='multipart/form-data',
follow_redirects=True
)
reupload = logged_in_client.post(
url_for('main.check_messages', service_id=fake_uuid, template_type='sms', upload_id='abc123'),
data={'file': (BytesIO(''.encode('utf-8')), 'invalid.csv')},
content_type='multipart/form-data',
follow_redirects=True
)
for response in [initial_upload, reupload]:
assert response.status_code == 200
content = response.get_data(as_text=True)
assert 'There is a problem with your data' in content
assert '+447700900986' in content
assert 'Missing' in content
assert 'Re-upload your file' in content
def test_upload_csv_invalid_extension(
app_,
logged_in_client,
api_user_active,
mocker,
mock_login,
@@ -133,22 +129,19 @@ def test_upload_csv_invalid_extension(
fake_uuid,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
resp = client.post(
url_for('main.send_messages', service_id=fake_uuid, template_id=fake_uuid),
data={'file': (BytesIO('contents'.encode('utf-8')), 'invalid.txt')},
content_type='multipart/form-data',
follow_redirects=True
)
resp = logged_in_client.post(
url_for('main.send_messages', service_id=fake_uuid, template_id=fake_uuid),
data={'file': (BytesIO('contents'.encode('utf-8')), 'invalid.txt')},
content_type='multipart/form-data',
follow_redirects=True
)
assert resp.status_code == 200
assert "invalid.txt isn’t a spreadsheet that Notify can read" in resp.get_data(as_text=True)
assert resp.status_code == 200
assert "invalid.txt isn’t a spreadsheet that Notify can read" in resp.get_data(as_text=True)
def test_send_test_sms_message(
app_,
logged_in_client,
mocker,
api_user_active,
mock_login,
@@ -164,19 +157,16 @@ def test_send_test_sms_message(
expected_data = {'data': 'phone number\r\n07700 900 762\r\n', 'file_name': 'Test message'}
mocker.patch('app.main.views.send.s3download', return_value='phone number\r\n+4412341234')
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.get(
url_for('main.send_test', service_id=fake_uuid, template_id=fake_uuid),
follow_redirects=True
)
assert response.status_code == 200
mock_s3_upload.assert_called_with(fake_uuid, expected_data, 'eu-west-1')
response = logged_in_client.get(
url_for('main.send_test', service_id=fake_uuid, template_id=fake_uuid),
follow_redirects=True
)
assert response.status_code == 200
mock_s3_upload.assert_called_with(fake_uuid, expected_data, 'eu-west-1')
def test_send_test_email_message(
app_,
logged_in_client,
mocker,
api_user_active,
mock_login,
@@ -192,19 +182,16 @@ def test_send_test_email_message(
expected_data = {'data': 'email address\r\ntest@user.gov.uk\r\n', 'file_name': 'Test message'}
mocker.patch('app.main.views.send.s3download', return_value='email address\r\ntest@user.gov.uk')
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.get(
url_for('main.send_test', service_id=fake_uuid, template_id=fake_uuid),
follow_redirects=True
)
assert response.status_code == 200
mock_s3_upload.assert_called_with(fake_uuid, expected_data, 'eu-west-1')
response = logged_in_client.get(
url_for('main.send_test', service_id=fake_uuid, template_id=fake_uuid),
follow_redirects=True
)
assert response.status_code == 200
mock_s3_upload.assert_called_with(fake_uuid, expected_data, 'eu-west-1')
def test_send_test_sms_message_with_placeholders(
app_,
logged_in_client,
mocker,
api_user_active,
mock_login,
@@ -223,24 +210,21 @@ def test_send_test_sms_message_with_placeholders(
}
mocker.patch('app.main.views.send.s3download', return_value='phone number\r\n+4412341234')
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.post(
url_for(
'main.send_test',
service_id=fake_uuid,
template_id=fake_uuid
),
data={'name': 'Jo'},
follow_redirects=True
)
assert response.status_code == 200
mock_s3_upload.assert_called_with(fake_uuid, expected_data, 'eu-west-1')
response = logged_in_client.post(
url_for(
'main.send_test',
service_id=fake_uuid,
template_id=fake_uuid
),
data={'name': 'Jo'},
follow_redirects=True
)
assert response.status_code == 200
mock_s3_upload.assert_called_with(fake_uuid, expected_data, 'eu-west-1')
def test_api_info_page(
app_,
logged_in_client,
mocker,
api_user_active,
mock_login,
@@ -250,19 +234,16 @@ def test_api_info_page(
mock_has_permissions,
fake_uuid
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.get(
url_for('main.send_from_api', service_id=fake_uuid, template_id=fake_uuid),
follow_redirects=True
)
assert response.status_code == 200
assert 'API info' in response.get_data(as_text=True)
response = logged_in_client.get(
url_for('main.send_from_api', service_id=fake_uuid, template_id=fake_uuid),
follow_redirects=True
)
assert response.status_code == 200
assert 'API info' in response.get_data(as_text=True)
def test_download_example_csv(
app_,
logged_in_client,
mocker,
api_user_active,
mock_login,
@@ -272,20 +253,17 @@ def test_download_example_csv(
fake_uuid
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.get(
url_for('main.get_example_csv', service_id=fake_uuid, template_id=fake_uuid),
follow_redirects=True
)
assert response.status_code == 200
assert response.get_data(as_text=True) == 'phone number\r\n07700 900321\r\n'
assert 'text/csv' in response.headers['Content-Type']
response = logged_in_client.get(
url_for('main.get_example_csv', service_id=fake_uuid, template_id=fake_uuid),
follow_redirects=True
)
assert response.status_code == 200
assert response.get_data(as_text=True) == 'phone number\r\n07700 900321\r\n'
assert 'text/csv' in response.headers['Content-Type']
def test_upload_csvfile_with_valid_phone_shows_all_numbers(
app_,
logged_in_client,
mocker,
api_user_active,
mock_login,
@@ -305,32 +283,29 @@ def test_upload_csvfile_with_valid_phone_shows_all_numbers(
])
)
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
response = client.post(
url_for('main.send_messages', service_id=fake_uuid, template_id=fake_uuid),
data={'file': (BytesIO(''.encode('utf-8')), 'valid.csv')},
content_type='multipart/form-data',
follow_redirects=True
)
with client.session_transaction() as sess:
assert sess['upload_data']['template_id'] == fake_uuid
assert sess['upload_data']['original_file_name'] == 'valid.csv'
assert sess['upload_data']['notification_count'] == 53
response = logged_in_client.post(
url_for('main.send_messages', service_id=fake_uuid, template_id=fake_uuid),
data={'file': (BytesIO(''.encode('utf-8')), 'valid.csv')},
content_type='multipart/form-data',
follow_redirects=True
)
with logged_in_client.session_transaction() as sess:
assert sess['upload_data']['template_id'] == fake_uuid
assert sess['upload_data']['original_file_name'] == 'valid.csv'
assert sess['upload_data']['notification_count'] == 53
content = response.get_data(as_text=True)
assert response.status_code == 200
assert '07700 900701' in content
assert '07700 900749' in content
assert '07700 900750' not in content
assert 'Only showing the first 50 rows' in content
content = response.get_data(as_text=True)
assert response.status_code == 200
assert '07700 900701' in content
assert '07700 900749' in content
assert '07700 900750' not in content
assert 'Only showing the first 50 rows' in content
mock_get_detailed_service_for_today.assert_called_once_with(fake_uuid)
mock_get_detailed_service_for_today.assert_called_once_with(fake_uuid)
def test_test_message_can_only_be_sent_now(
app_,
logged_in_client,
mocker,
api_user_active,
mock_login,
@@ -343,25 +318,23 @@ def test_test_message_can_only_be_sent_now(
fake_uuid
):
with app_.test_request_context(), app_.test_client() as client:
client.login(api_user_active)
with client.session_transaction() as session:
session['upload_data'] = {
'original_file_name': 'Test message',
'template_id': fake_uuid,
'notification_count': 1,
'valid': True
}
response = client.get(url_for(
'main.check_messages',
service_id=fake_uuid,
upload_id=fake_uuid,
template_type='sms',
from_test=True
))
with logged_in_client.session_transaction() as session:
session['upload_data'] = {
'original_file_name': 'Test message',
'template_id': fake_uuid,
'notification_count': 1,
'valid': True
}
response = logged_in_client.get(url_for(
'main.check_messages',
service_id=fake_uuid,
upload_id=fake_uuid,
template_type='sms',
from_test=True
))
content = response.get_data(as_text=True)
assert 'name="scheduled_for"' not in content
content = response.get_data(as_text=True)
assert 'name="scheduled_for"' not in content
@pytest.mark.parametrize(
@@ -370,7 +343,7 @@ def test_test_message_can_only_be_sent_now(
]
)
def test_create_job_should_call_api(
app_,
logged_in_client,
service_one,
active_user_with_permissions,
mock_create_job,
@@ -387,17 +360,15 @@ def test_create_job_should_call_api(
original_file_name = data['original_file_name']
template_id = data['template']
notification_count = data['notification_count']
with app_.test_request_context(), app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service_one)
with client.session_transaction() as session:
session['upload_data'] = {
'original_file_name': original_file_name,
'template_id': template_id,
'notification_count': notification_count,
'valid': True
}
url = url_for('main.start_job', service_id=service_one['id'], upload_id=job_id)
response = client.post(url, data={'scheduled_for': when}, follow_redirects=True)
with logged_in_client.session_transaction() as session:
session['upload_data'] = {
'original_file_name': original_file_name,
'template_id': template_id,
'notification_count': notification_count,
'valid': True
}
url = url_for('main.start_job', service_id=service_one['id'], upload_id=job_id)
response = logged_in_client.post(url, data={'scheduled_for': when}, follow_redirects=True)
assert response.status_code == 200
assert original_file_name in response.get_data(as_text=True)
@@ -480,7 +451,7 @@ def test_should_show_preview_letter_message(
def test_check_messages_should_revalidate_file_when_uploading_file(
app_,
logged_in_client,
service_one,
active_user_with_permissions,
mock_create_job,
@@ -505,22 +476,19 @@ def test_check_messages_should_revalidate_file_when_uploading_file(
"""
)
data = mock_get_job(service_one['id'], fake_uuid)['data']
with app_.test_request_context():
with app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service_one)
with client.session_transaction() as session:
session['upload_data'] = {'original_file_name': 'invalid.csv',
'template_id': data['template'],
'notification_count': data['notification_count'],
'valid': True}
response = client.post(
url_for('main.start_job', service_id=service_id, upload_id=data['id']),
data={'file': (BytesIO(''.encode('utf-8')), 'invalid.csv')},
content_type='multipart/form-data',
follow_redirects=True
)
assert response.status_code == 200
assert 'There is a problem with your data' in response.get_data(as_text=True)
with logged_in_client.session_transaction() as session:
session['upload_data'] = {'original_file_name': 'invalid.csv',
'template_id': data['template'],
'notification_count': data['notification_count'],
'valid': True}
response = logged_in_client.post(
url_for('main.start_job', service_id=service_id, upload_id=data['id']),
data={'file': (BytesIO(''.encode('utf-8')), 'invalid.csv')},
content_type='multipart/form-data',
follow_redirects=True
)
assert response.status_code == 200
assert 'There is a problem with your data' in response.get_data(as_text=True)
@pytest.mark.parametrize('route, response_code', [
@@ -532,6 +500,7 @@ def test_check_messages_should_revalidate_file_when_uploading_file(
def test_route_permissions(
mocker,
app_,
client,
api_user_active,
service_one,
mock_get_service_template,
@@ -544,20 +513,19 @@ def test_route_permissions(
route,
response_code,
):
with app_.test_request_context():
validate_route_permission(
mocker,
app_,
"GET",
response_code,
url_for(
route,
service_id=service_one['id'],
template_type='sms',
template_id=fake_uuid),
['send_texts', 'send_emails', 'send_letters'],
api_user_active,
service_one)
validate_route_permission(
mocker,
app_,
"GET",
response_code,
url_for(
route,
service_id=service_one['id'],
template_type='sms',
template_id=fake_uuid),
['send_texts', 'send_emails', 'send_letters'],
api_user_active,
service_one)
@pytest.mark.parametrize('route', [
@@ -569,6 +537,7 @@ def test_route_permissions(
def test_route_invalid_permissions(
mocker,
app_,
client,
api_user_active,
service_one,
mock_get_service_template,
@@ -579,25 +548,25 @@ def test_route_invalid_permissions(
fake_uuid,
route,
):
with app_.test_request_context():
validate_route_permission(
mocker,
app_,
"GET",
403,
url_for(
route,
service_id=service_one['id'],
template_type='sms',
template_id=fake_uuid),
['blah'],
api_user_active,
service_one)
validate_route_permission(
mocker,
app_,
"GET",
403,
url_for(
route,
service_id=service_one['id'],
template_type='sms',
template_id=fake_uuid),
['blah'],
api_user_active,
service_one)
def test_route_choose_template_manage_service_permissions(
mocker,
app_,
client,
api_user_active,
service_one,
mock_login,
@@ -607,38 +576,38 @@ def test_route_choose_template_manage_service_permissions(
mock_get_service_templates,
mock_get_jobs,
):
with app_.test_request_context():
template_id = mock_get_service_templates(service_one['id'])['data'][0]['id']
resp = validate_route_permission(
mocker,
app_,
"GET",
200,
url_for(
'main.choose_template',
service_id=service_one['id'],
template_type='sms'),
['manage_users', 'manage_templates', 'manage_settings'],
api_user_active,
service_one)
page = resp.get_data(as_text=True)
assert url_for(
"main.send_messages",
template_id = mock_get_service_templates(service_one['id'])['data'][0]['id']
resp = validate_route_permission(
mocker,
app_,
"GET",
200,
url_for(
'main.choose_template',
service_id=service_one['id'],
template_id=template_id) not in page
assert url_for(
"main.send_test",
service_id=service_one['id'],
template_id=template_id) not in page
assert url_for(
"main.edit_service_template",
service_id=service_one['id'],
template_id=template_id) in page
template_type='sms'),
['manage_users', 'manage_templates', 'manage_settings'],
api_user_active,
service_one)
page = resp.get_data(as_text=True)
assert url_for(
"main.send_messages",
service_id=service_one['id'],
template_id=template_id) not in page
assert url_for(
"main.send_test",
service_id=service_one['id'],
template_id=template_id) not in page
assert url_for(
"main.edit_service_template",
service_id=service_one['id'],
template_id=template_id) in page
def test_route_choose_template_send_messages_permissions(
mocker,
app_,
client,
active_user_with_permissions,
service_one,
mock_get_service,
@@ -646,38 +615,38 @@ def test_route_choose_template_send_messages_permissions(
mock_get_service_templates,
mock_get_jobs,
):
with app_.test_request_context():
template_id = None
for temp in mock_get_service_templates(service_one['id'])['data']:
if temp['template_type'] == 'sms':
template_id = temp['id']
assert template_id
resp = validate_route_permission(
mocker,
app_,
"GET",
200,
url_for(
'main.choose_template',
service_id=service_one['id'],
template_type='sms'),
['send_texts', 'send_emails', 'send_letters'],
active_user_with_permissions,
service_one)
page = resp.get_data(as_text=True)
assert url_for(
"main.send_messages",
template_id = None
for temp in mock_get_service_templates(service_one['id'])['data']:
if temp['template_type'] == 'sms':
template_id = temp['id']
assert template_id
resp = validate_route_permission(
mocker,
app_,
"GET",
200,
url_for(
'main.choose_template',
service_id=service_one['id'],
template_id=template_id) in page
assert url_for(
"main.edit_service_template",
service_id=service_one['id'],
template_id=template_id) not in page
template_type='sms'),
['send_texts', 'send_emails', 'send_letters'],
active_user_with_permissions,
service_one)
page = resp.get_data(as_text=True)
assert url_for(
"main.send_messages",
service_id=service_one['id'],
template_id=template_id) in page
assert url_for(
"main.edit_service_template",
service_id=service_one['id'],
template_id=template_id) not in page
def test_route_choose_template_manage_api_keys_permissions(
mocker,
app_,
client,
api_user_active,
service_one,
mock_get_user,
@@ -686,39 +655,38 @@ def test_route_choose_template_manage_api_keys_permissions(
mock_get_service_templates,
mock_get_jobs,
):
with app_.test_request_context():
template_id = None
for temp in mock_get_service_templates(service_one['id'])['data']:
if temp['template_type'] == 'sms':
template_id = temp['id']
assert template_id
resp = validate_route_permission(
mocker,
app_,
"GET",
200,
url_for(
'main.choose_template',
service_id=service_one['id'],
template_type='sms'),
['manage_api_keys'],
api_user_active,
service_one)
page = resp.get_data(as_text=True)
assert url_for(
"main.send_test",
template_id = None
for temp in mock_get_service_templates(service_one['id'])['data']:
if temp['template_type'] == 'sms':
template_id = temp['id']
assert template_id
resp = validate_route_permission(
mocker,
app_,
"GET",
200,
url_for(
'main.choose_template',
service_id=service_one['id'],
template_id=template_id) not in page
assert url_for(
"main.edit_service_template",
service_id=service_one['id'],
template_id=template_id) not in page
page = BeautifulSoup(resp.data.decode('utf-8'), 'html.parser')
links = page.findAll('a', href=re.compile('^' + url_for(
"main.send_from_api",
service_id=service_one['id'],
template_id=template_id)))
assert len(links) == 1
template_type='sms'),
['manage_api_keys'],
api_user_active,
service_one)
page = resp.get_data(as_text=True)
assert url_for(
"main.send_test",
service_id=service_one['id'],
template_id=template_id) not in page
assert url_for(
"main.edit_service_template",
service_id=service_one['id'],
template_id=template_id) not in page
page = BeautifulSoup(resp.data.decode('utf-8'), 'html.parser')
links = page.findAll('a', href=re.compile('^' + url_for(
"main.send_from_api",
service_id=service_one['id'],
template_id=template_id)))
assert len(links) == 1
@pytest.mark.parametrize(
@@ -739,7 +707,7 @@ def test_route_choose_template_manage_api_keys_permissions(
]
)
def test_check_messages_back_link(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_get_user_by_email,
@@ -753,30 +721,28 @@ def test_check_messages_back_link(
extra_args,
expected_url
):
with app_.test_request_context(), app_.test_client() as client:
client.login(api_user_active)
with client.session_transaction() as session:
session['upload_data'] = {'original_file_name': 'valid.csv',
'template_id': fake_uuid,
'notification_count': 1,
'valid': True}
response = client.get(url_for(
'main.check_messages',
service_id=fake_uuid,
upload_id=fake_uuid,
template_type='sms',
from_test=True,
**extra_args
))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert (
page.findAll('a', {'class': 'page-footer-back-link'})[0]['href']
) == expected_url(service_id=fake_uuid, template_id=fake_uuid)
with logged_in_client.session_transaction() as session:
session['upload_data'] = {'original_file_name': 'valid.csv',
'template_id': fake_uuid,
'notification_count': 1,
'valid': True}
response = logged_in_client.get(url_for(
'main.check_messages',
service_id=fake_uuid,
upload_id=fake_uuid,
template_type='sms',
from_test=True,
**extra_args
))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert (
page.findAll('a', {'class': 'page-footer-back-link'})[0]['href']
) == expected_url(service_id=fake_uuid, template_id=fake_uuid)
def test_go_to_dashboard_after_tour(
app_,
logged_in_client,
mocker,
api_user_active,
mock_login,
@@ -786,16 +752,13 @@ def test_go_to_dashboard_after_tour(
fake_uuid
):
with app_.test_request_context(), app_.test_client() as client:
client.login(api_user_active)
resp = logged_in_client.get(
url_for('main.go_to_dashboard_after_tour', service_id=fake_uuid, example_template_id=fake_uuid)
)
resp = client.get(
url_for('main.go_to_dashboard_after_tour', service_id=fake_uuid, example_template_id=fake_uuid)
)
assert resp.status_code == 302
assert resp.location == url_for("main.service_dashboard", service_id=fake_uuid, _external=True)
mock_delete_service_template.assert_called_once_with(fake_uuid, fake_uuid)
assert resp.status_code == 302
assert resp.location == url_for("main.service_dashboard", service_id=fake_uuid, _external=True)
mock_delete_service_template.assert_called_once_with(fake_uuid, fake_uuid)
@pytest.mark.parametrize('num_requested,expected_msg', [
@@ -804,7 +767,7 @@ def test_go_to_dashboard_after_tour(
], ids=['none_sent', 'some_sent'])
def test_check_messages_shows_too_many_messages_errors(
mocker,
app_,
logged_in_client,
api_user_active,
mock_login,
mock_get_users_by_service,
@@ -828,19 +791,17 @@ def test_check_messages_shows_too_many_messages_errors(
}
})
with app_.test_request_context(), app_.test_client() as client:
client.login(api_user_active)
with client.session_transaction() as session:
session['upload_data'] = {'original_file_name': 'valid.csv',
'template_id': fake_uuid,
'notification_count': 1,
'valid': True}
response = client.get(url_for(
'main.check_messages',
service_id=fake_uuid,
template_type='sms',
upload_id=fake_uuid
))
with logged_in_client.session_transaction() as session:
session['upload_data'] = {'original_file_name': 'valid.csv',
'template_id': fake_uuid,
'notification_count': 1,
'valid': True}
response = logged_in_client.get(url_for(
'main.check_messages',
service_id=fake_uuid,
template_type='sms',
upload_id=fake_uuid
))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.find('h1').text.strip() == 'Too many recipients'
@@ -883,8 +844,7 @@ def test_check_messages_shows_trial_mode_error(
def test_check_messages_shows_over_max_row_error(
client,
app_,
logged_in_client,
api_user_active,
mock_login,
mock_get_users_by_service,
@@ -901,10 +861,9 @@ def test_check_messages_shows_over_max_row_error(
mock_recipients.__len__.return_value = 99999
mock_recipients.too_many_rows.return_value = True
client.login(api_user_active)
with client.session_transaction() as session:
with logged_in_client.session_transaction() as session:
session['upload_data'] = {'template_id': fake_uuid}
response = client.get(url_for(
response = logged_in_client.get(url_for(
'main.check_messages',
service_id=fake_uuid,
template_type='sms',

790
tests/app/main/views/test_service_settings.py
View File

File diff suppressed because it is too large Load Diff

93
tests/app/main/views/test_sign_in.py
View File

@@ -3,10 +3,9 @@ from bs4 import BeautifulSoup
def test_render_sign_in_returns_sign_in_template(
app_
client
):
with app_.test_request_context():
response = app_.test_client().get(url_for('main.sign_in'))
response = client.get(url_for('main.sign_in'))
assert response.status_code == 200
assert 'Sign in' in response.get_data(as_text=True)
assert 'Email address' in response.get_data(as_text=True)
@@ -22,94 +21,87 @@ def test_logged_in_user_redirects_to_choose_service(
def test_process_sign_in_return_2fa_template(
app_,
client,
api_user_active,
mock_send_verify_code,
mock_get_user,
mock_get_user_by_email,
mock_verify_password,
):
with app_.test_request_context():
response = app_.test_client().post(
url_for('main.sign_in'), data={
'email_address': 'valid@example.gov.uk',
'password': 'val1dPassw0rd!'})
assert response.status_code == 302
assert response.location == url_for('.two_factor', _external=True)
response = client.post(
url_for('main.sign_in'), data={
'email_address': 'valid@example.gov.uk',
'password': 'val1dPassw0rd!'})
assert response.status_code == 302
assert response.location == url_for('.two_factor', _external=True)
mock_verify_password.assert_called_with(api_user_active.id, 'val1dPassw0rd!')
def test_should_return_locked_out_true_when_user_is_locked(
app_,
client,
mock_get_user_by_email_locked,
):
with app_.test_request_context():
resp = app_.test_client().post(
url_for('main.sign_in'), data={
'email_address': 'valid@example.gov.uk',
'password': 'whatIsMyPassword!'})
assert resp.status_code == 200
assert 'The email address or password you entered is incorrect' in resp.get_data(as_text=True)
resp = client.post(
url_for('main.sign_in'), data={
'email_address': 'valid@example.gov.uk',
'password': 'whatIsMyPassword!'})
assert resp.status_code == 200
assert 'The email address or password you entered is incorrect' in resp.get_data(as_text=True)
def test_should_return_200_when_user_does_not_exist(
app_,
client,
mock_get_user_by_email_not_found,
):
with app_.test_request_context():
response = app_.test_client().post(
url_for('main.sign_in'), data={
'email_address': 'notfound@gov.uk',
'password': 'doesNotExist!'})
response = client.post(
url_for('main.sign_in'), data={
'email_address': 'notfound@gov.uk',
'password': 'doesNotExist!'})
assert response.status_code == 200
assert 'The email address or password you entered is incorrect' in response.get_data(as_text=True)
def test_should_return_redirect_when_user_is_pending(
app_,
client,
mock_get_user_by_email_pending,
mock_verify_password,
):
with app_.test_request_context():
response = app_.test_client().post(
url_for('main.sign_in'), data={
'email_address': 'pending_user@example.gov.uk',
'password': 'val1dPassw0rd!'}, follow_redirects=True)
response = client.post(
url_for('main.sign_in'), data={
'email_address': 'pending_user@example.gov.uk',
'password': 'val1dPassw0rd!'}, follow_redirects=True)
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string == 'Sign in'
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string == 'Sign in'
assert response.status_code == 200
def test_should_attempt_redirect_when_user_is_pending(
app_,
client,
mock_get_user_by_email_pending,
mock_verify_password,
):
with app_.test_request_context():
response = app_.test_client().post(
url_for('main.sign_in'), data={
'email_address': 'pending_user@example.gov.uk',
'password': 'val1dPassw0rd!'})
assert response.location == url_for('main.resend_email_verification', _external=True)
assert response.status_code == 302
response = client.post(
url_for('main.sign_in'), data={
'email_address': 'pending_user@example.gov.uk',
'password': 'val1dPassw0rd!'})
assert response.location == url_for('main.resend_email_verification', _external=True)
assert response.status_code == 302
def test_not_fresh_session_login_redirects_to_dashboard(
client,
logged_in_client,
api_user_active,
mock_login,
mock_get_user_by_email,
mock_verify_password,
mock_get_services_with_one_service,
):
client.login(api_user_active)
with client.session_transaction() as session:
with logged_in_client.session_transaction() as session:
assert session['_fresh']
session['_fresh'] = False
# This should skip the two factor
response = client.post(
response = logged_in_client.post(
url_for('main.sign_in'), data={
'email_address': api_user_active.email_address,
'password': 'val1dPassw0rd!'})
@@ -120,19 +112,18 @@ def test_not_fresh_session_login_redirects_to_dashboard(
def test_not_fresh_session_login_redirects_to_choose_service(
client,
logged_in_client,
api_user_active,
mock_login,
mock_get_user_by_email,
mock_verify_password,
mock_get_services,
):
client.login(api_user_active)
with client.session_transaction() as session:
with logged_in_client.session_transaction() as session:
assert session['_fresh']
session['_fresh'] = False
# This should skip the two factor
response = client.post(
response = logged_in_client.post(
url_for('main.sign_in'), data={
'email_address': api_user_active.email_address,
'password': 'val1dPassw0rd!'})

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

@@ -2,18 +2,17 @@ from flask import url_for
def test_render_sign_out_redirects_to_sign_in(
app_
client
):
with app_.test_request_context():
response = app_.test_client().get(
url_for('main.sign_out'))
assert response.status_code == 302
assert response.location == url_for(
'main.index', _external=True)
response = client.get(
url_for('main.sign_out'))
assert response.status_code == 302
assert response.location == url_for(
'main.index', _external=True)
def test_sign_out_user(
app_,
logged_in_client,
mock_get_service,
api_user_active,
mock_get_user,
@@ -26,18 +25,15 @@ def test_sign_out_user(
mock_get_detailed_service,
mock_get_usage,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
with client.session_transaction() as session:
assert session.get('user_id') is not None
# Check we are logged in
response = client.get(
url_for('main.service_dashboard', service_id="123"))
assert response.status_code == 200
response = client.get(url_for('main.sign_out'))
assert response.status_code == 302
assert response.location == url_for(
'main.index', _external=True)
with client.session_transaction() as session:
assert session.get('user_id') is None
with logged_in_client.session_transaction() as session:
assert session.get('user_id') is not None
# Check we are logged in
response = logged_in_client.get(
url_for('main.service_dashboard', service_id="123"))
assert response.status_code == 200
response = logged_in_client.get(url_for('main.sign_out'))
assert response.status_code == 302
assert response.location == url_for(
'main.index', _external=True)
with logged_in_client.session_transaction() as session:
assert session.get('user_id') is None

52
tests/app/main/views/test_template_history.py
View File

@@ -3,7 +3,7 @@ from flask import url_for
def test_view_template_version(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_get_service,
@@ -13,22 +13,19 @@ def test_view_template_version(
mock_has_permissions,
fake_uuid,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
service_id = fake_uuid
template_id = fake_uuid
version = 1
all_versions_link = url_for(
'main.view_template_versions',
service_id=service_id,
template_id=template_id
)
resp = client.get(url_for(
'.view_template_version',
service_id=service_id,
template_id=template_id,
version=version))
service_id = fake_uuid
template_id = fake_uuid
version = 1
all_versions_link = url_for(
'main.view_template_versions',
service_id=service_id,
template_id=template_id
)
resp = logged_in_client.get(url_for(
'.view_template_version',
service_id=service_id,
template_id=template_id,
version=version))
assert resp.status_code == 200
resp_data = resp.get_data(as_text=True)
@@ -44,7 +41,7 @@ def test_view_template_version(
def test_view_template_versions(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_get_service,
@@ -55,17 +52,14 @@ def test_view_template_versions(
mock_has_permissions,
fake_uuid,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
service_id = fake_uuid
template_id = fake_uuid
version = 1
resp = client.get(url_for(
'.view_template_versions',
service_id=service_id,
template_id=template_id
))
service_id = fake_uuid
template_id = fake_uuid
version = 1
resp = logged_in_client.get(url_for(
'.view_template_versions',
service_id=service_id,
template_id=template_id
))
assert resp.status_code == 200
resp_data = resp.get_data(as_text=True)

651
tests/app/main/views/test_templates.py
View File

@@ -14,7 +14,7 @@ from app.main.views.templates import get_last_use_message, get_human_readable_de
def test_should_show_page_for_one_template(
app_,
client,
active_user_with_permissions,
mocker,
mock_get_service_template,
@@ -22,16 +22,13 @@ def test_should_show_page_for_one_template(
):
service = create_sample_service(active_user_with_permissions)
with app_.test_request_context():
with app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service)
mocker.patch('app.user_api_client.get_users_for_service', return_value=[active_user_with_permissions])
service_id = service['id']
template_id = fake_uuid
response = client.get(url_for(
'.edit_service_template',
service_id=service_id,
template_id=template_id))
client.login(active_user_with_permissions, mocker, service)
service_id = service['id']
template_id = fake_uuid
response = client.get(url_for(
'.edit_service_template',
service_id=service_id,
template_id=template_id))
assert response.status_code == 200
assert "Two week reminder" in response.get_data(as_text=True)
@@ -42,7 +39,7 @@ def test_should_show_page_for_one_template(
def test_should_show_page_template_with_priority_select_if_platform_admin(
app_,
logged_in_client,
platform_admin_user,
mocker,
mock_get_service_template,
@@ -50,16 +47,13 @@ def test_should_show_page_template_with_priority_select_if_platform_admin(
):
service = create_sample_service(platform_admin_user)
with app_.test_request_context():
with app_.test_client() as client:
client.login(platform_admin_user, mocker, service)
mocker.patch('app.user_api_client.get_users_for_service', return_value=[platform_admin_user])
service_id = service['id']
template_id = fake_uuid
response = client.get(url_for(
'.edit_service_template',
service_id=service_id,
template_id=template_id))
mocker.patch('app.user_api_client.get_users_for_service', return_value=[platform_admin_user])
service_id = service['id']
template_id = fake_uuid
response = logged_in_client.get(url_for(
'.edit_service_template',
service_id=service_id,
template_id=template_id))
assert response.status_code == 200
assert "Two week reminder" in response.get_data(as_text=True)
@@ -84,7 +78,7 @@ def test_should_show_preview_letter_templates(
extra_view_args,
view_suffix,
expected_content_type,
client,
logged_in_client,
api_user_active,
mock_login,
mock_get_service,
@@ -95,9 +89,8 @@ def test_should_show_preview_letter_templates(
fake_uuid,
mocker,
):
client.login(api_user_active)
service_id, template_id = repeat(fake_uuid, 2)
response = client.get(url_for(
response = logged_in_client.get(url_for(
'{}_{}'.format(view, view_suffix),
service_id=service_id,
template_id=template_id,
@@ -116,7 +109,7 @@ def test_should_show_preview_letter_templates(
def test_should_redirect_when_saving_a_template(
app_,
logged_in_client,
active_user_with_permissions,
mocker,
mock_get_service_template,
@@ -124,35 +117,32 @@ def test_should_redirect_when_saving_a_template(
fake_uuid,
):
service = create_sample_service(active_user_with_permissions)
with app_.test_request_context():
with app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service)
mocker.patch('app.user_api_client.get_users_for_service', return_value=[active_user_with_permissions])
template_id = fake_uuid
name = "new name"
content = "template <em>content</em> with & entity"
data = {
'id': template_id,
'name': name,
'template_content': content,
'template_type': 'sms',
'service': service['id'],
'process_type': 'normal'
}
response = client.post(url_for(
'.edit_service_template',
service_id=service['id'],
template_id=template_id), data=data)
mocker.patch('app.user_api_client.get_users_for_service', return_value=[active_user_with_permissions])
template_id = fake_uuid
name = "new name"
content = "template <em>content</em> with & entity"
data = {
'id': template_id,
'name': name,
'template_content': content,
'template_type': 'sms',
'service': service['id'],
'process_type': 'normal'
}
response = logged_in_client.post(url_for(
'.edit_service_template',
service_id=service['id'],
template_id=template_id), data=data)
assert response.status_code == 302
assert response.location == url_for(
'.view_template', service_id=service['id'], template_id=template_id, _external=True)
mock_update_service_template.assert_called_with(
template_id, name, 'sms', content, service['id'], None, 'normal')
assert response.status_code == 302
assert response.location == url_for(
'.view_template', service_id=service['id'], template_id=template_id, _external=True)
mock_update_service_template.assert_called_with(
template_id, name, 'sms', content, service['id'], None, 'normal')
def test_should_edit_content_when_process_type_is_priority_not_platform_admin(
app_,
logged_in_client,
active_user_with_permissions,
mocker,
mock_get_service_template_with_priority,
@@ -160,39 +150,36 @@ def test_should_edit_content_when_process_type_is_priority_not_platform_admin(
fake_uuid,
):
service = create_sample_service(active_user_with_permissions)
with app_.test_request_context():
with app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service)
mocker.patch('app.user_api_client.get_users_for_service', return_value=[active_user_with_permissions])
template_id = fake_uuid
data = {
'id': template_id,
'name': "new name",
'template_content': "new template <em>content</em> with & entity",
'template_type': 'sms',
'service': service['id'],
'process_type': 'priority'
}
response = client.post(url_for(
'.edit_service_template',
service_id=service['id'],
template_id=template_id), data=data)
assert response.status_code == 302
assert response.location == url_for(
'.view_template', service_id=service['id'], template_id=template_id, _external=True)
mock_update_service_template.assert_called_with(
template_id,
"new name",
'sms',
"new template <em>content</em> with & entity",
service['id'],
None,
'priority'
)
mocker.patch('app.user_api_client.get_users_for_service', return_value=[active_user_with_permissions])
template_id = fake_uuid
data = {
'id': template_id,
'name': "new name",
'template_content': "new template <em>content</em> with & entity",
'template_type': 'sms',
'service': service['id'],
'process_type': 'priority'
}
response = logged_in_client.post(url_for(
'.edit_service_template',
service_id=service['id'],
template_id=template_id), data=data)
assert response.status_code == 302
assert response.location == url_for(
'.view_template', service_id=service['id'], template_id=template_id, _external=True)
mock_update_service_template.assert_called_with(
template_id,
"new name",
'sms',
"new template <em>content</em> with & entity",
service['id'],
None,
'priority'
)
def test_should_403_when_edit_template_with_process_type_of_priority_for_non_platform_admin(
app_,
client,
active_user_with_permissions,
mocker,
mock_get_service_template,
@@ -200,29 +187,27 @@ def test_should_403_when_edit_template_with_process_type_of_priority_for_non_pla
fake_uuid,
):
service = create_sample_service(active_user_with_permissions)
with app_.test_request_context():
with app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service)
mocker.patch('app.user_api_client.get_users_for_service', return_value=[active_user_with_permissions])
template_id = fake_uuid
data = {
'id': template_id,
'name': "new name",
'template_content': "template <em>content</em> with & entity",
'template_type': 'sms',
'service': service['id'],
'process_type': 'priority'
}
response = client.post(url_for(
'.edit_service_template',
service_id=service['id'],
template_id=template_id), data=data)
assert response.status_code == 403
mock_update_service_template.called == 0
client.login(active_user_with_permissions, mocker, service)
mocker.patch('app.user_api_client.get_users_for_service', return_value=[active_user_with_permissions])
template_id = fake_uuid
data = {
'id': template_id,
'name': "new name",
'template_content': "template <em>content</em> with & entity",
'template_type': 'sms',
'service': service['id'],
'process_type': 'priority'
}
response = client.post(url_for(
'.edit_service_template',
service_id=service['id'],
template_id=template_id), data=data)
assert response.status_code == 403
mock_update_service_template.called == 0
def test_should_403_when_create_template_with_process_type_of_priority_for_non_platform_admin(
app_,
client,
active_user_with_permissions,
mocker,
mock_get_service_template,
@@ -230,29 +215,27 @@ def test_should_403_when_create_template_with_process_type_of_priority_for_non_p
fake_uuid,
):
service = create_sample_service(active_user_with_permissions)
with app_.test_request_context():
with app_.test_client() as client:
client.login(active_user_with_permissions, mocker, service)
mocker.patch('app.user_api_client.get_users_for_service', return_value=[active_user_with_permissions])
template_id = fake_uuid
data = {
'id': template_id,
'name': "new name",
'template_content': "template <em>content</em> with & entity",
'template_type': 'sms',
'service': service['id'],
'process_type': 'priority'
}
response = client.post(url_for(
'.add_service_template',
service_id=service['id'],
template_type='sms'), data=data)
assert response.status_code == 403
mock_update_service_template.called == 0
client.login(active_user_with_permissions, mocker, service)
mocker.patch('app.user_api_client.get_users_for_service', return_value=[active_user_with_permissions])
template_id = fake_uuid
data = {
'id': template_id,
'name': "new name",
'template_content': "template <em>content</em> with & entity",
'template_type': 'sms',
'service': service['id'],
'process_type': 'priority'
}
response = client.post(url_for(
'.add_service_template',
service_id=service['id'],
template_type='sms'), data=data)
assert response.status_code == 403
mock_update_service_template.called == 0
def test_should_show_interstitial_when_making_breaking_change(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_get_service_email_template,
@@ -263,41 +246,38 @@ def test_should_show_interstitial_when_making_breaking_change(
mock_has_permissions,
fake_uuid,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
service_id = fake_uuid
template_id = fake_uuid
response = client.post(
url_for('.edit_service_template', service_id=service_id, template_id=template_id),
data={
'id': template_id,
'name': "new name",
'template_content': "hello",
'template_type': 'email',
'subject': 'reminder',
'service': service_id,
'process_type': 'normal'
}
)
service_id = fake_uuid
template_id = fake_uuid
response = logged_in_client.post(
url_for('.edit_service_template', service_id=service_id, template_id=template_id),
data={
'id': template_id,
'name': "new name",
'template_content': "hello",
'template_type': 'email',
'subject': 'reminder',
'service': service_id,
'process_type': 'normal'
}
)
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == "Confirm changes"
assert page.find('a', {'class': 'page-footer-back-link'})['href'] == url_for(".edit_service_template",
service_id=service_id,
template_id=template_id)
for key, value in {
'name': 'new name',
'subject': 'reminder',
'template_content': 'hello',
'confirm': 'true'
}.items():
assert page.find('input', {'name': key})['value'] == value
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.string.strip() == "Confirm changes"
assert page.find('a', {'class': 'page-footer-back-link'})['href'] == url_for(".edit_service_template",
service_id=service_id,
template_id=template_id)
for key, value in {
'name': 'new name',
'subject': 'reminder',
'template_content': 'hello',
'confirm': 'true'
}.items():
assert page.find('input', {'name': key})['value'] == value
def test_should_not_create_too_big_template(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_get_service_template,
@@ -308,30 +288,27 @@ def test_should_not_create_too_big_template(
mock_has_permissions,
fake_uuid,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
service_id = fake_uuid
template_type = 'sms'
data = {
'name': "new name",
'template_content': "template content",
'template_type': template_type,
'service': service_id,
'process_type': 'normal'
}
resp = client.post(url_for(
'.add_service_template',
service_id=service_id,
template_type=template_type
), data=data)
service_id = fake_uuid
template_type = 'sms'
data = {
'name': "new name",
'template_content': "template content",
'template_type': template_type,
'service': service_id,
'process_type': 'normal'
}
resp = logged_in_client.post(url_for(
'.add_service_template',
service_id=service_id,
template_type=template_type
), data=data)
assert resp.status_code == 200
assert "Content has a character count greater than the limit of 459" in resp.get_data(as_text=True)
assert resp.status_code == 200
assert "Content has a character count greater than the limit of 459" in resp.get_data(as_text=True)
def test_should_not_update_too_big_template(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_get_service_template,
@@ -342,30 +319,27 @@ def test_should_not_update_too_big_template(
mock_has_permissions,
fake_uuid,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
service_id = fake_uuid
template_id = fake_uuid
data = {
'id': fake_uuid,
'name': "new name",
'template_content': "template content",
'service': service_id,
'template_type': 'sms',
'process_type': 'normal'
}
resp = client.post(url_for(
'.edit_service_template',
service_id=service_id,
template_id=template_id), data=data)
service_id = fake_uuid
template_id = fake_uuid
data = {
'id': fake_uuid,
'name': "new name",
'template_content': "template content",
'service': service_id,
'template_type': 'sms',
'process_type': 'normal'
}
resp = logged_in_client.post(url_for(
'.edit_service_template',
service_id=service_id,
template_id=template_id), data=data)
assert resp.status_code == 200
assert "Content has a character count greater than the limit of 459" in resp.get_data(as_text=True)
assert resp.status_code == 200
assert "Content has a character count greater than the limit of 459" in resp.get_data(as_text=True)
def test_should_redirect_when_saving_a_template_email(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_get_service_email_template,
@@ -376,39 +350,36 @@ def test_should_redirect_when_saving_a_template_email(
mock_has_permissions,
fake_uuid,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
service_id = fake_uuid
template_id = fake_uuid
name = "new name"
content = "template <em>content</em> with & entity ((thing)) ((date))"
subject = "subject"
data = {
'id': template_id,
'name': name,
'template_content': content,
'template_type': 'email',
'service': service_id,
'subject': subject,
'process_type': 'normal'
}
response = client.post(url_for(
'.edit_service_template',
service_id=service_id,
template_id=template_id), data=data)
assert response.status_code == 302
assert response.location == url_for(
'.view_template',
service_id=service_id,
template_id=template_id,
_external=True)
mock_update_service_template.assert_called_with(
template_id, name, 'email', content, service_id, subject, 'normal')
service_id = fake_uuid
template_id = fake_uuid
name = "new name"
content = "template <em>content</em> with & entity ((thing)) ((date))"
subject = "subject"
data = {
'id': template_id,
'name': name,
'template_content': content,
'template_type': 'email',
'service': service_id,
'subject': subject,
'process_type': 'normal'
}
response = logged_in_client.post(url_for(
'.edit_service_template',
service_id=service_id,
template_id=template_id), data=data)
assert response.status_code == 302
assert response.location == url_for(
'.view_template',
service_id=service_id,
template_id=template_id,
_external=True)
mock_update_service_template.assert_called_with(
template_id, name, 'email', content, service_id, subject, 'normal')
def test_should_show_delete_template_page_with_time_block(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_get_service,
@@ -419,23 +390,20 @@ def test_should_show_delete_template_page_with_time_block(
fake_uuid,
mocker,
):
with app_.test_request_context():
with app_.test_client() as client:
with freeze_time('2012-01-01 12:00:00'):
template = template_json('1234', '1234', "Test template", "sms", "Something very interesting")
notification = single_notification_json('1234', template=template)
with freeze_time('2012-01-01 12:00:00'):
template = template_json('1234', '1234', "Test template", "sms", "Something very interesting")
notification = single_notification_json('1234', template=template)
mocker.patch('app.template_statistics_client.get_template_statistics_for_template',
return_value=notification)
mocker.patch('app.template_statistics_client.get_template_statistics_for_template',
return_value=notification)
with freeze_time('2012-01-01 12:10:00'):
client.login(api_user_active)
service_id = fake_uuid
template_id = fake_uuid
response = client.get(url_for(
'.delete_service_template',
service_id=service_id,
template_id=template_id))
with freeze_time('2012-01-01 12:10:00'):
service_id = fake_uuid
template_id = fake_uuid
response = logged_in_client.get(url_for(
'.delete_service_template',
service_id=service_id,
template_id=template_id))
content = response.get_data(as_text=True)
assert response.status_code == 200
assert 'Test template was last used 10 minutes ago. Are you sure you want to delete it?' in content
@@ -446,7 +414,7 @@ def test_should_show_delete_template_page_with_time_block(
def test_should_show_delete_template_page_with_never_used_block(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_get_service,
@@ -457,32 +425,28 @@ def test_should_show_delete_template_page_with_never_used_block(
fake_uuid,
mocker,
):
with app_.test_request_context():
with app_.test_client() as client:
mocker.patch(
'app.template_statistics_client.get_template_statistics_for_template',
side_effect=HTTPError(response=Mock(status_code=404), message="Default message")
)
mocker.patch(
'app.template_statistics_client.get_template_statistics_for_template',
side_effect=HTTPError(response=Mock(status_code=404), message="Default message")
)
service_id = fake_uuid
template_id = fake_uuid
response = logged_in_client.get(url_for(
'.delete_service_template',
service_id=service_id,
template_id=template_id))
client.login(api_user_active)
service_id = fake_uuid
template_id = fake_uuid
response = client.get(url_for(
'.delete_service_template',
service_id=service_id,
template_id=template_id))
content = response.get_data(as_text=True)
assert response.status_code == 200
assert 'Two week reminder has never been used. Are you sure you want to delete it?' in content
assert 'Are you sure' in content
assert 'Two week reminder' in content
assert 'Template &lt;em&gt;content&lt;/em&gt; with &amp; entity' in content
mock_get_service_template.assert_called_with(service_id, template_id)
content = response.get_data(as_text=True)
assert response.status_code == 200
assert 'Two week reminder has never been used. Are you sure you want to delete it?' in content
assert 'Are you sure' in content
assert 'Two week reminder' in content
assert 'Template &lt;em&gt;content&lt;/em&gt; with &amp; entity' in content
mock_get_service_template.assert_called_with(service_id, template_id)
def test_should_redirect_when_deleting_a_template(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_get_service,
@@ -493,40 +457,37 @@ def test_should_redirect_when_deleting_a_template(
mock_has_permissions,
fake_uuid,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
service_id = fake_uuid
template_id = fake_uuid
name = "new name"
type_ = "sms"
content = "template content"
data = {
'id': str(template_id),
'name': name,
'template_type': type_,
'content': content,
'service': service_id
}
response = client.post(url_for(
'.delete_service_template',
service_id=service_id,
template_id=template_id
), data=data)
service_id = fake_uuid
template_id = fake_uuid
name = "new name"
type_ = "sms"
content = "template content"
data = {
'id': str(template_id),
'name': name,
'template_type': type_,
'content': content,
'service': service_id
}
response = logged_in_client.post(url_for(
'.delete_service_template',
service_id=service_id,
template_id=template_id
), data=data)
assert response.status_code == 302
assert response.location == url_for(
'.choose_template',
service_id=service_id, template_type=type_, _external=True)
mock_get_service_template.assert_called_with(
service_id, template_id)
mock_delete_service_template.assert_called_with(
service_id, template_id)
assert response.status_code == 302
assert response.location == url_for(
'.choose_template',
service_id=service_id, template_type=type_, _external=True)
mock_get_service_template.assert_called_with(
service_id, template_id)
mock_delete_service_template.assert_called_with(
service_id, template_id)
@freeze_time('2016-01-01T15:00')
def test_should_show_page_for_a_deleted_template(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_get_service,
@@ -536,25 +497,23 @@ def test_should_show_page_for_a_deleted_template(
mock_has_permissions,
fake_uuid,
):
with app_.test_request_context(), app_.test_client() as client:
client.login(api_user_active)
service_id = fake_uuid
template_id = fake_uuid
response = client.get(url_for(
'.view_template',
service_id=service_id,
template_id=template_id
))
service_id = fake_uuid
template_id = fake_uuid
response = logged_in_client.get(url_for(
'.view_template',
service_id=service_id,
template_id=template_id
))
assert response.status_code == 200
assert response.status_code == 200
content = response.get_data(as_text=True)
assert url_for("main.edit_service_template", service_id=fake_uuid, template_id=fake_uuid) not in content
assert url_for("main.send_from_api", service_id=fake_uuid, template_id=fake_uuid) not in content
assert url_for("main.send_test", service_id=fake_uuid, template_id=fake_uuid) not in content
assert "This template was deleted<br/>1 January 2016" in content
content = response.get_data(as_text=True)
assert url_for("main.edit_service_template", service_id=fake_uuid, template_id=fake_uuid) not in content
assert url_for("main.send_from_api", service_id=fake_uuid, template_id=fake_uuid) not in content
assert url_for("main.send_test", service_id=fake_uuid, template_id=fake_uuid) not in content
assert "This template was deleted<br/>1 January 2016" in content
mock_get_deleted_template.assert_called_with(service_id, template_id)
mock_get_deleted_template.assert_called_with(service_id, template_id)
@pytest.mark.parametrize('route', [
@@ -566,49 +525,49 @@ def test_route_permissions(
route,
mocker,
app_,
client,
api_user_active,
service_one,
mock_get_service_template,
mock_get_template_statistics_for_template,
fake_uuid,
):
with app_.test_request_context():
validate_route_permission(
mocker,
app_,
"GET",
200,
url_for(
route,
service_id=service_one['id'],
template_type='sms',
template_id=fake_uuid),
['manage_templates'],
api_user_active,
service_one)
validate_route_permission(
mocker,
app_,
"GET",
200,
url_for(
route,
service_id=service_one['id'],
template_type='sms',
template_id=fake_uuid),
['manage_templates'],
api_user_active,
service_one)
def test_route_permissions_for_choose_template(
mocker,
app_,
client,
api_user_active,
service_one,
mock_get_service_templates,
):
mocker.patch('app.job_api_client.get_job')
with app_.test_request_context():
validate_route_permission(
mocker,
app_,
"GET",
200,
url_for(
'main.choose_template',
service_id=service_one['id'],
template_type='sms'),
['view_activity'],
api_user_active,
service_one)
validate_route_permission(
mocker,
app_,
"GET",
200,
url_for(
'main.choose_template',
service_id=service_one['id'],
template_type='sms'),
['view_activity'],
api_user_active,
service_one)
@pytest.mark.parametrize('route', [
@@ -620,26 +579,26 @@ def test_route_invalid_permissions(
route,
mocker,
app_,
client,
api_user_active,
service_one,
mock_get_service_template,
mock_get_template_statistics_for_template,
fake_uuid,
):
with app_.test_request_context():
validate_route_permission(
mocker,
app_,
"GET",
403,
url_for(
route,
service_id=service_one['id'],
template_type='sms',
template_id=fake_uuid),
['view_activity'],
api_user_active,
service_one)
validate_route_permission(
mocker,
app_,
"GET",
403,
url_for(
route,
service_id=service_one['id'],
template_type='sms',
template_id=fake_uuid),
['view_activity'],
api_user_active,
service_one)
def test_get_last_use_message_returns_no_template_message():

289
tests/app/main/views/test_two_factor.py
View File

@@ -5,25 +5,23 @@ from unittest.mock import ANY
def test_should_render_two_factor_page(
app_,
client,
api_user_active,
mock_get_user_by_email,
):
with app_.test_request_context():
with app_.test_client() as client:
# TODO this lives here until we work out how to
# reassign the session after it is lost mid register process
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.two_factor'))
assert response.status_code == 200
assert '''We’ve sent you a text message with a security code.''' in response.get_data(as_text=True)
# TODO this lives here until we work out how to
# reassign the session after it is lost mid register process
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.two_factor'))
assert response.status_code == 200
assert '''We’ve sent you a text message with a security code.''' in response.get_data(as_text=True)
def test_should_login_user_and_redirect_to_service_dashboard(
app_,
client,
api_user_active,
mock_get_user,
mock_get_user_by_email,
@@ -31,223 +29,202 @@ def test_should_login_user_and_redirect_to_service_dashboard(
mock_get_services_with_one_service,
mock_events,
):
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.two_factor'),
data={'sms_code': '12345'})
assert response.status_code == 302
assert response.location == url_for(
'main.service_dashboard',
service_id=SERVICE_ONE_ID,
_external=True
)
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.two_factor'),
data={'sms_code': '12345'})
assert response.status_code == 302
assert response.location == url_for(
'main.service_dashboard',
service_id=SERVICE_ONE_ID,
_external=True
)
mock_events.assert_called_with('sucessful_login', ANY)
mock_events.assert_called_with('sucessful_login', ANY)
def test_should_login_user_and_should_redirect_to_next_url(
app_,
client,
api_user_active,
mock_get_user,
mock_get_user_by_email,
mock_check_verify_code,
mock_get_services,
):
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.two_factor', next='/services/{}/dashboard'.format(SERVICE_ONE_ID)),
data={'sms_code': '12345'})
assert response.status_code == 302
assert response.location == url_for(
'main.service_dashboard',
service_id=SERVICE_ONE_ID,
_external=True
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.two_factor', next='/services/{}/dashboard'.format(SERVICE_ONE_ID)),
data={'sms_code': '12345'})
assert response.status_code == 302
assert response.location == url_for(
'main.service_dashboard',
service_id=SERVICE_ONE_ID,
_external=True
)
def test_should_login_user_and_not_redirect_to_external_url(
app_,
client,
api_user_active,
mock_get_user,
mock_get_user_by_email,
mock_check_verify_code,
mock_get_services_with_one_service,
):
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.two_factor', next='http://www.google.com'),
data={'sms_code': '12345'})
assert response.status_code == 302
assert response.location == url_for(
'main.service_dashboard',
service_id=SERVICE_ONE_ID,
_external=True
)
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.two_factor', next='http://www.google.com'),
data={'sms_code': '12345'})
assert response.status_code == 302
assert response.location == url_for(
'main.service_dashboard',
service_id=SERVICE_ONE_ID,
_external=True
)
def test_should_login_user_and_redirect_to_choose_services(
app_,
client,
api_user_active,
mock_get_user,
mock_get_user_by_email,
mock_check_verify_code,
mock_get_services,
):
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.two_factor'),
data={'sms_code': '12345'})
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.two_factor'),
data={'sms_code': '12345'})
assert response.status_code == 302
assert response.location == url_for('main.choose_service', _external=True)
assert response.status_code == 302
assert response.location == url_for('main.choose_service', _external=True)
def test_should_return_200_with_sms_code_error_when_sms_code_is_wrong(
app_,
client,
api_user_active,
mock_get_user_by_email,
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'] = {
'id': api_user_active.id,
'email': api_user_active.email_address}
response = client.post(url_for('main.two_factor'),
data={'sms_code': '23456'})
assert response.status_code == 200
assert 'Code not found' in response.get_data(as_text=True)
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.two_factor'),
data={'sms_code': '23456'})
assert response.status_code == 200
assert 'Code not found' in response.get_data(as_text=True)
def test_should_login_user_when_multiple_valid_codes_exist(
app_,
client,
api_user_active,
mock_get_user,
mock_get_user_by_email,
mock_check_verify_code,
mock_get_services_with_one_service,
):
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.two_factor'),
data={'sms_code': '23456'})
assert response.status_code == 302
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.two_factor'),
data={'sms_code': '23456'})
assert response.status_code == 302
def test_remember_me_set(
app_,
client,
api_user_active,
mock_get_user,
mock_get_user_by_email,
mock_check_verify_code,
mock_get_services_with_one_service,
):
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.two_factor'),
data={'sms_code': '23456', 'remember_me': True})
assert response.status_code == 302
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.two_factor'),
data={'sms_code': '23456', 'remember_me': True})
assert response.status_code == 302
def test_two_factor_should_set_password_when_new_password_exists_in_session(
app_,
client,
api_user_active,
mock_get_user,
mock_check_verify_code,
mock_get_services_with_one_service,
mock_update_user,
):
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,
'password': 'changedpassword'}
with client.session_transaction() as session:
session['user_details'] = {
'id': api_user_active.id,
'email': api_user_active.email_address,
'password': 'changedpassword'}
response = client.post(url_for('main.two_factor'),
data={'sms_code': '12345'})
assert response.status_code == 302
assert response.location == url_for(
'main.service_dashboard',
service_id=SERVICE_ONE_ID,
_external=True
)
api_user_active.password = 'changedpassword'
mock_update_user.assert_called_once_with(api_user_active)
response = client.post(url_for('main.two_factor'),
data={'sms_code': '12345'})
assert response.status_code == 302
assert response.location == url_for(
'main.service_dashboard',
service_id=SERVICE_ONE_ID,
_external=True
)
api_user_active.password = 'changedpassword'
mock_update_user.assert_called_once_with(api_user_active)
def test_two_factor_reset_login_count_called(
app_,
client,
api_user_locked,
mock_get_locked_user,
mock_update_user,
mock_check_verify_code,
mock_get_services_with_one_service,
):
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
new_password = "1234567890"
session['user_details'] = {
'id': api_user_locked.id,
'email': api_user_locked.email_address,
'password': new_password
}
response = client.post(url_for('main.two_factor'),
data={'sms_code': '12345'})
assert response.status_code == 302
assert response.location == url_for(
'main.service_dashboard',
service_id=SERVICE_ONE_ID,
_external=True
)
api_user_locked.reset_failed_login_count()
api_user_locked.password = new_password
mock_update_user.assert_called_with(api_user_locked)
with client.session_transaction() as session:
new_password = "1234567890"
session['user_details'] = {
'id': api_user_locked.id,
'email': api_user_locked.email_address,
'password': new_password
}
response = client.post(url_for('main.two_factor'),
data={'sms_code': '12345'})
assert response.status_code == 302
assert response.location == url_for(
'main.service_dashboard',
service_id=SERVICE_ONE_ID,
_external=True
)
api_user_locked.reset_failed_login_count()
api_user_locked.password = new_password
mock_update_user.assert_called_with(api_user_locked)
def test_two_factor_should_redirect_to_sign_in_if_user_not_in_session(
app_,
client,
api_user_active,
mock_get_user,
):
with app_.test_request_context():
with app_.test_client() as client:
response = client.post(url_for('main.two_factor'),
data={'sms_code': '12345'})
assert response.status_code == 302
assert response.location == url_for('main.sign_in', _external=True)
response = client.post(url_for('main.two_factor'),
data={'sms_code': '12345'})
assert response.status_code == 302
assert response.location == url_for('main.sign_in', _external=True)
def test_two_factor_should_activate_pending_user(
app_,
client,
mocker,
api_user_pending,
mock_check_verify_code,
@@ -255,14 +232,12 @@ def test_two_factor_should_activate_pending_user(
):
mocker.patch('app.user_api_client.get_user', return_value=api_user_pending)
mocker.patch('app.service_api_client.get_services', return_value={'data': []})
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_details'] = {
'id': api_user_pending.id,
'email_address': api_user_pending.email_address
}
client.post(url_for('main.two_factor'), data={'sms_code': '12345'})
with client.session_transaction() as session:
session['user_details'] = {
'id': api_user_pending.id,
'email_address': api_user_pending.email_address
}
client.post(url_for('main.two_factor'), data={'sms_code': '12345'})
assert mock_update_user.called
assert api_user_pending.is_active
assert mock_update_user.called
assert api_user_pending.is_active

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

@@ -4,322 +4,273 @@ from notifications_utils.url_safe_token import generate_token
def test_should_show_overview_page(
app_,
logged_in_client,
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'))
response = logged_in_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_,
logged_in_client,
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'))
response = logged_in_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_,
logged_in_client,
api_user_active,
mock_login,
mock_get_user,
mock_update_user_attribute,
):
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)
new_name = 'New Name'
data = {'new_name': new_name}
response = logged_in_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_attribute.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_attribute.called
def test_should_show_email_page(
app_,
logged_in_client,
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'))
response = logged_in_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_,
logged_in_client,
api_user_active,
mock_login,
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)
data = {'email_address': 'new_notify@notify.gov.uk'}
response = logged_in_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_,
logged_in_client,
api_user_active,
mock_login,
):
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'))
with logged_in_client.session_transaction() as session:
session['new-email'] = 'new_notify@notify.gov.uk'
response = logged_in_client.get(url_for('main.user_profile_email_authenticate'))
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
assert 'Change your email address' in response.get_data(as_text=True)
assert 'Confirm' in response.get_data(as_text=True)
def test_should_render_change_email_continue_after_authenticate_email(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_verify_password,
mock_send_change_email_verification,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
data = {'password': '12345'}
with client.session_transaction() as session:
session['new-email'] = 'new_notify@notify.gov.uk'
response = client.post(
url_for('main.user_profile_email_authenticate'),
data=data)
assert response.status_code == 200
assert 'Click the link in the email to confirm the change to your email address.' \
in response.get_data(as_text=True)
data = {'password': '12345'}
with logged_in_client.session_transaction() as session:
session['new-email'] = 'new_notify@notify.gov.uk'
response = logged_in_client.post(
url_for('main.user_profile_email_authenticate'),
data=data)
assert response.status_code == 200
assert 'Click the link in the email to confirm the change to your email address.' \
in response.get_data(as_text=True)
def test_should_redirect_to_user_profile_when_user_confirms_email_link(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_update_user_attribute,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
token = generate_token(payload=json.dumps({'user_id': api_user_active.id, 'email': 'new_email@gov.uk'}),
secret=app_.config['SECRET_KEY'], salt=app_.config['DANGEROUS_SALT'])
response = client.get(url_for('main.user_profile_email_confirm', token=token))
token = generate_token(payload=json.dumps({'user_id': api_user_active.id, 'email': 'new_email@gov.uk'}),
secret=app_.config['SECRET_KEY'], salt=app_.config['DANGEROUS_SALT'])
response = logged_in_client.get(url_for('main.user_profile_email_confirm', token=token))
assert response.status_code == 302
assert response.location == url_for('main.user_profile', _external=True)
assert response.status_code == 302
assert response.location == url_for('main.user_profile', _external=True)
def test_should_show_mobile_number_page(
app_,
logged_in_client,
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_mobile_number'))
response = logged_in_client.get(url_for('main.user_profile_mobile_number'))
assert 'Change your mobile number' in response.get_data(as_text=True)
assert response.status_code == 200
assert 'Change your mobile number' in response.get_data(as_text=True)
assert response.status_code == 200
def test_should_redirect_after_mobile_number_change(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_get_user,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
data = {'mobile_number': '07121231234'}
response = client.post(
url_for('main.user_profile_mobile_number'),
data=data)
assert response.status_code == 302
assert response.location == url_for(
'main.user_profile_mobile_number_authenticate', _external=True)
data = {'mobile_number': '07121231234'}
response = logged_in_client.post(
url_for('main.user_profile_mobile_number'),
data=data)
assert response.status_code == 302
assert response.location == url_for(
'main.user_profile_mobile_number_authenticate', _external=True)
def test_should_show_authenticate_after_mobile_number_change(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_get_user,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
with client.session_transaction() as session:
session['new-mob'] = '+441234123123'
response = client.get(
url_for('main.user_profile_mobile_number_authenticate'))
with logged_in_client.session_transaction() as session:
session['new-mob'] = '+441234123123'
response = logged_in_client.get(
url_for('main.user_profile_mobile_number_authenticate'))
assert 'Change your mobile number' in response.get_data(as_text=True)
assert 'Confirm' in response.get_data(as_text=True)
assert response.status_code == 200
assert 'Change your mobile number' 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_mobile_number_authenticate(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_get_user,
mock_verify_password,
mock_send_verify_code,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
with client.session_transaction() as session:
session['new-mob'] = '+441234123123'
data = {'password': '12345667'}
response = client.post(
url_for('main.user_profile_mobile_number_authenticate'),
data=data)
with logged_in_client.session_transaction() as session:
session['new-mob'] = '+441234123123'
data = {'password': '12345667'}
response = logged_in_client.post(
url_for('main.user_profile_mobile_number_authenticate'),
data=data)
assert response.status_code == 302
assert response.location == url_for(
'main.user_profile_mobile_number_confirm', _external=True)
assert response.status_code == 302
assert response.location == url_for(
'main.user_profile_mobile_number_confirm', _external=True)
def test_should_show_confirm_after_mobile_number_change(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_get_user,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
with client.session_transaction() as session:
session['new-mob-password-confirmed'] = True
response = client.get(
url_for('main.user_profile_mobile_number_confirm'))
with logged_in_client.session_transaction() as session:
session['new-mob-password-confirmed'] = True
response = logged_in_client.get(
url_for('main.user_profile_mobile_number_confirm'))
assert 'Change your mobile number' in response.get_data(as_text=True)
assert 'Confirm' in response.get_data(as_text=True)
assert response.status_code == 200
assert 'Change your mobile number' 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_mobile_number_confirm(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_get_user,
mock_update_user_attribute,
mock_check_verify_code,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
with client.session_transaction() as session:
session['new-mob-password-confirmed'] = True
session['new-mob'] = '+441234123123'
data = {'sms_code': '12345'}
response = client.post(
url_for('main.user_profile_mobile_number_confirm'),
data=data)
assert response.status_code == 302
assert response.location == url_for(
'main.user_profile', _external=True)
with logged_in_client.session_transaction() as session:
session['new-mob-password-confirmed'] = True
session['new-mob'] = '+441234123123'
data = {'sms_code': '12345'}
response = logged_in_client.post(
url_for('main.user_profile_mobile_number_confirm'),
data=data)
assert response.status_code == 302
assert response.location == url_for(
'main.user_profile', _external=True)
def test_should_show_password_page(
app_,
logged_in_client,
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_password'))
response = logged_in_client.get(url_for('main.user_profile_password'))
assert 'Change your password' in response.get_data(as_text=True)
assert response.status_code == 200
assert 'Change your password' in response.get_data(as_text=True)
assert response.status_code == 200
def test_should_redirect_after_password_change(
app_,
logged_in_client,
api_user_active,
mock_login,
mock_get_user,
mock_update_user,
mock_verify_password,
):
with app_.test_request_context():
with app_.test_client() as client:
client.login(api_user_active)
data = {
'new_password': 'the new password',
'old_password': 'the old password'}
response = client.post(
url_for('main.user_profile_password'),
data=data)
data = {
'new_password': 'the new password',
'old_password': 'the old password'}
response = logged_in_client.post(
url_for('main.user_profile_password'),
data=data)
assert response.status_code == 302
assert response.location == url_for(
'main.user_profile', _external=True)
assert response.status_code == 302
assert response.location == url_for(
'main.user_profile', _external=True)
def test_non_gov_user_cannot_see_change_email_link(
client,
logged_in_client,
api_nongov_user_active,
mock_login,
mock_get_non_govuser,
):
client.login(api_nongov_user_active)
response = client.get(url_for('main.user_profile'))
response = logged_in_client.get(url_for('main.user_profile'))
assert '<a href="/user-profile/email">' not in response.get_data(as_text=True)
assert 'Your profile' in response.get_data(as_text=True)
assert response.status_code == 200
def test_non_gov_user_cannot_access_change_email_page(
client,
logged_in_client,
api_nongov_user_active,
mock_login,
mock_get_non_govuser,
):
client.login(api_nongov_user_active)
response = client.get(url_for('main.user_profile_email'))
response = logged_in_client.get(url_for('main.user_profile_email'))
assert response.status_code == 403

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

@@ -4,46 +4,42 @@ from bs4 import BeautifulSoup
def test_should_return_verify_template(
app_,
client,
api_user_active,
mock_send_verify_code,
):
with app_.test_request_context():
with app_.test_client() as client:
# TODO this lives here until we work out how to
# reassign the session after it is lost mid register process
with client.session_transaction() as session:
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
# TODO this lives here until we work out how to
# reassign the session after it is lost mid register process
with client.session_transaction() as session:
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
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.text == 'Check your phone'
message = page.find_all('p')[1].text
assert message == "We’ve sent you a text message with a security code."
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.text == 'Check your phone'
message = page.find_all('p')[1].text
assert message == "We’ve sent you a text message with a security code."
def test_should_redirect_to_add_service_when_sms_code_is_correct(
app_,
client,
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 == 302
assert response.location == url_for('main.add_service', first='first', _external=True)
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 == 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')
mock_check_verify_code.assert_called_once_with(api_user_active.id, '12345', 'sms')
def test_should_activate_user_after_verify(
app_,
client,
mocker,
api_user_pending,
mock_send_verify_code,
@@ -51,34 +47,30 @@ def test_should_activate_user_after_verify(
mock_update_user,
):
mocker.patch('app.user_api_client.get_user', return_value=api_user_pending)
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_details'] = {'email_address': api_user_pending.email_address, 'id': api_user_pending.id}
client.post(url_for('main.verify'),
data={'sms_code': '12345'})
assert mock_update_user.called
with client.session_transaction() as session:
session['user_details'] = {'email_address': api_user_pending.email_address, 'id': api_user_pending.id}
client.post(url_for('main.verify'),
data={'sms_code': '12345'})
assert mock_update_user.called
def test_should_return_200_when_sms_code_is_wrong(
app_,
client,
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'})
assert response.status_code == 200
resp_data = response.get_data(as_text=True)
assert resp_data.count('Code not found') == 1
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
resp_data = response.get_data(as_text=True)
assert resp_data.count('Code not found') == 1
def test_verify_email_redirects_to_verify_if_token_valid(
app_,
client,
mocker,
api_user_pending,
mock_get_user_pending,
@@ -89,19 +81,17 @@ def test_verify_email_redirects_to_verify_if_token_valid(
token_data = {"user_id": api_user_pending.id, "secret_code": 12345}
mocker.patch('app.main.views.verify.check_token', return_value=json.dumps(token_data))
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_details'] = {'email_address': api_user_pending.email_address, 'id': api_user_pending.id}
with client.session_transaction() as session:
session['user_details'] = {'email_address': api_user_pending.email_address, 'id': api_user_pending.id}
response = client.get(url_for('main.verify_email', token='notreal'))
response = client.get(url_for('main.verify_email', token='notreal'))
assert response.status_code == 302
assert response.location == url_for('main.verify', _external=True)
assert response.status_code == 302
assert response.location == url_for('main.verify', _external=True)
def test_verify_email_redirects_to_email_sent_if_token_expired(
app_,
client,
mocker,
api_user_pending,
mock_check_verify_code,
@@ -109,19 +99,17 @@ def test_verify_email_redirects_to_email_sent_if_token_expired(
from itsdangerous import SignatureExpired
mocker.patch('app.main.views.verify.check_token', side_effect=SignatureExpired('expired'))
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_details'] = {'email_address': api_user_pending.email_address, 'id': api_user_pending.id}
with client.session_transaction() as session:
session['user_details'] = {'email_address': api_user_pending.email_address, 'id': api_user_pending.id}
response = client.get(url_for('main.verify_email', token='notreal'))
response = client.get(url_for('main.verify_email', token='notreal'))
assert response.status_code == 302
assert response.location == url_for('main.resend_email_verification', _external=True)
assert response.status_code == 302
assert response.location == url_for('main.resend_email_verification', _external=True)
def test_verify_email_redirects_to_email_sent_if_token_used(
app_,
client,
mocker,
api_user_pending,
mock_get_user_pending,
@@ -131,19 +119,17 @@ def test_verify_email_redirects_to_email_sent_if_token_used(
from itsdangerous import SignatureExpired
mocker.patch('app.main.views.verify.check_token', side_effect=SignatureExpired('expired'))
with app_.test_request_context():
with app_.test_client() as client:
with client.session_transaction() as session:
session['user_details'] = {'email_address': api_user_pending.email_address, 'id': api_user_pending.id}
with client.session_transaction() as session:
session['user_details'] = {'email_address': api_user_pending.email_address, 'id': api_user_pending.id}
response = client.get(url_for('main.verify_email', token='notreal'))
response = client.get(url_for('main.verify_email', token='notreal'))
assert response.status_code == 302
assert response.location == url_for('main.resend_email_verification', _external=True)
assert response.status_code == 302
assert response.location == url_for('main.resend_email_verification', _external=True)
def test_verify_email_redirects_to_sign_in_if_user_active(
app_,
client,
mocker,
api_user_active,
mock_get_user,
@@ -154,23 +140,20 @@ def test_verify_email_redirects_to_sign_in_if_user_active(
token_data = {"user_id": api_user_active.id, "secret_code": 12345}
mocker.patch('app.main.views.verify.check_token', return_value=json.dumps(token_data))
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}
with client.session_transaction() as session:
session['user_details'] = {'email_address': api_user_active.email_address, 'id': api_user_active.id}
response = client.get(url_for('main.verify_email', token='notreal'), follow_redirects=True)
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.text == 'Sign in'
flash_banner = page.find('div', class_='banner-dangerous').string.strip()
assert flash_banner == "That verification link has expired."
response = client.get(url_for('main.verify_email', token='notreal'), follow_redirects=True)
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.h1.text == 'Sign in'
flash_banner = page.find('div', class_='banner-dangerous').string.strip()
assert flash_banner == "That verification link has expired."
def test_verify_redirects_to_sign_in_if_not_logged_in(
app_
client
):
with app_.test_request_context(), app_.test_client() as client:
response = client.get(url_for('main.verify'))
response = client.get(url_for('main.verify'))
assert response.location == url_for('main.sign_in', _external=True)
assert response.status_code == 302
assert response.location == url_for('main.sign_in', _external=True)
assert response.status_code == 302

1
tests/conftest.py
View File

@@ -570,6 +570,7 @@ def active_user_with_permissions(fake_uuid):
user_data = {'id': fake_uuid,
'name': 'Test User',
'password': 'somepassword',
'password_changed_at': str(datetime.utcnow()),
'email_address': 'test@user.gov.uk',
'mobile_number': '07700 900762',
'state': 'active',