mirror of
https://github.com/GSA/notifications-admin.git
synced 2026-07-31 20:00:00 -04:00
04966e4051
We don’t want sanitized content going into the database, because sometimes we need the content unsanitised. The path from admin to the API is where the template goes on it’s way to the database. So let’s make sure we’re not sanitizing it at this stage.
650 lines
26 KiB
Python
650 lines
26 KiB
Python
from itertools import repeat
|
|
from datetime import datetime
|
|
from unittest.mock import Mock, patch
|
|
|
|
import pytest
|
|
from bs4 import BeautifulSoup
|
|
from flask import url_for
|
|
from freezegun import freeze_time
|
|
from notifications_python_client.errors import HTTPError
|
|
from tests.conftest import service_one as create_sample_service
|
|
from tests import validate_route_permission, template_json, single_notification_json
|
|
|
|
from app.main.views.templates import get_last_use_message, get_human_readable_delta
|
|
|
|
|
|
def test_should_show_page_for_one_template(
|
|
app_,
|
|
active_user_with_permissions,
|
|
mocker,
|
|
mock_get_service_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])
|
|
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)
|
|
assert "Template <em>content</em> with & entity" in response.get_data(as_text=True)
|
|
assert "Use priority queue?" not in response.get_data(as_text=True)
|
|
mock_get_service_template.assert_called_with(
|
|
service_id, template_id)
|
|
|
|
|
|
def test_should_show_page_template_with_priority_select_if_platform_admin(
|
|
app_,
|
|
platform_admin_user,
|
|
mocker,
|
|
mock_get_service_template,
|
|
fake_uuid
|
|
):
|
|
|
|
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))
|
|
|
|
assert response.status_code == 200
|
|
assert "Two week reminder" in response.get_data(as_text=True)
|
|
assert "Template <em>content</em> with & entity" in response.get_data(as_text=True)
|
|
assert "Use priority queue?" in response.get_data(as_text=True)
|
|
mock_get_service_template.assert_called_with(
|
|
service_id, template_id)
|
|
|
|
|
|
@pytest.mark.parametrize('view_suffix, expected_content_type', [
|
|
('as_pdf', 'application/pdf'),
|
|
('as_png', 'image/png'),
|
|
])
|
|
@pytest.mark.parametrize('view, extra_view_args', [
|
|
('.view_letter_template', {}),
|
|
('.view_template_version', {'version': 1}),
|
|
])
|
|
@patch('app.main.views.templates.LetterPreviewTemplate.jinja_template.render', return_value='foo')
|
|
def test_should_show_preview_letter_templates(
|
|
mock_letter_preview,
|
|
view,
|
|
extra_view_args,
|
|
view_suffix,
|
|
expected_content_type,
|
|
client,
|
|
api_user_active,
|
|
mock_login,
|
|
mock_get_service,
|
|
mock_get_service_email_template,
|
|
mock_get_user,
|
|
mock_get_user_by_email,
|
|
mock_has_permissions,
|
|
fake_uuid,
|
|
mocker
|
|
):
|
|
client.login(api_user_active)
|
|
service_id, template_id = repeat(fake_uuid, 2)
|
|
response = client.get(url_for(
|
|
'{}_{}'.format(view, view_suffix),
|
|
service_id=service_id,
|
|
template_id=template_id,
|
|
**extra_view_args
|
|
))
|
|
|
|
assert response.status_code == 200
|
|
assert response.content_type == expected_content_type
|
|
mock_get_service_email_template.assert_called_with(service_id, template_id, **extra_view_args)
|
|
print(mock_letter_preview)
|
|
print(mock_letter_preview.call_args)
|
|
assert mock_letter_preview.call_args[0][0]['message'] == (
|
|
"<h2>Your <span class='placeholder'>((thing))</span> is due soon</h2>\n"
|
|
"<p>Your vehicle tax expires on <span class='placeholder'>((date))</span></p>"
|
|
)
|
|
|
|
|
|
def test_should_redirect_when_saving_a_template(app_,
|
|
active_user_with_permissions,
|
|
mocker,
|
|
mock_get_service_template,
|
|
mock_update_service_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)
|
|
|
|
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_,
|
|
active_user_with_permissions,
|
|
mocker,
|
|
mock_get_service_template_with_priority,
|
|
mock_update_service_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
|
|
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'
|
|
)
|
|
|
|
|
|
def test_should_403_when_edit_template_with_process_type_of_priority_for_non_platform_admin(
|
|
app_,
|
|
active_user_with_permissions,
|
|
mocker,
|
|
mock_get_service_template,
|
|
mock_update_service_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
|
|
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_,
|
|
active_user_with_permissions,
|
|
mocker,
|
|
mock_get_service_template,
|
|
mock_update_service_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
|
|
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_,
|
|
api_user_active,
|
|
mock_login,
|
|
mock_get_service_email_template,
|
|
mock_update_service_template,
|
|
mock_get_user,
|
|
mock_get_service,
|
|
mock_get_user_by_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
|
|
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'
|
|
}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
|
|
assert page.h1.string.strip() == "Confirm changes"
|
|
|
|
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_,
|
|
api_user_active,
|
|
mock_login,
|
|
mock_get_service_template,
|
|
mock_get_user,
|
|
mock_get_service,
|
|
mock_get_user_by_email,
|
|
mock_create_service_template_content_too_big,
|
|
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)
|
|
|
|
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_,
|
|
api_user_active,
|
|
mock_login,
|
|
mock_get_service_template,
|
|
mock_get_user,
|
|
mock_get_service,
|
|
mock_get_user_by_email,
|
|
mock_update_service_template_400_content_too_big,
|
|
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)
|
|
|
|
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_,
|
|
api_user_active,
|
|
mock_login,
|
|
mock_get_service_email_template,
|
|
mock_update_service_template,
|
|
mock_get_user,
|
|
mock_get_service,
|
|
mock_get_user_by_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')
|
|
|
|
|
|
def test_should_show_delete_template_page_with_time_block(app_,
|
|
api_user_active,
|
|
mock_login,
|
|
mock_get_service,
|
|
mock_get_service_template,
|
|
mock_get_user,
|
|
mock_get_user_by_email,
|
|
mock_has_permissions,
|
|
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)
|
|
|
|
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))
|
|
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
|
|
assert 'Are you sure' in content
|
|
assert 'Two week reminder' in content
|
|
assert 'Template <em>content</em> with & entity' in content
|
|
mock_get_service_template.assert_called_with(service_id, template_id)
|
|
|
|
|
|
def test_should_show_delete_template_page_with_never_used_block(app_,
|
|
api_user_active,
|
|
mock_login,
|
|
mock_get_service,
|
|
mock_get_service_template,
|
|
mock_get_user,
|
|
mock_get_user_by_email,
|
|
mock_has_permissions,
|
|
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")
|
|
)
|
|
|
|
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 <em>content</em> with & entity' in content
|
|
mock_get_service_template.assert_called_with(service_id, template_id)
|
|
|
|
|
|
def test_should_redirect_when_deleting_a_template(app_,
|
|
api_user_active,
|
|
mock_login,
|
|
mock_get_service,
|
|
mock_get_service_template,
|
|
mock_delete_service_template,
|
|
mock_get_user,
|
|
mock_get_user_by_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"
|
|
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)
|
|
|
|
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_,
|
|
api_user_active,
|
|
mock_login,
|
|
mock_get_service,
|
|
mock_get_deleted_template,
|
|
mock_get_user,
|
|
mock_get_user_by_email,
|
|
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
|
|
))
|
|
|
|
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
|
|
|
|
mock_get_deleted_template.assert_called_with(service_id, template_id)
|
|
|
|
|
|
@pytest.mark.parametrize('route', [
|
|
'main.add_service_template',
|
|
'main.edit_service_template',
|
|
'main.delete_service_template'
|
|
])
|
|
def test_route_permissions(route,
|
|
mocker,
|
|
app_,
|
|
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)
|
|
|
|
|
|
def test_route_permissions_for_choose_template(mocker,
|
|
app_,
|
|
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)
|
|
|
|
|
|
@pytest.mark.parametrize('route', [
|
|
'main.add_service_template',
|
|
'main.edit_service_template',
|
|
'main.delete_service_template'
|
|
])
|
|
def test_route_invalid_permissions(route,
|
|
mocker,
|
|
app_,
|
|
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)
|
|
|
|
|
|
def test_get_last_use_message_returns_no_template_message():
|
|
assert get_last_use_message('My Template', []) == 'My Template has never been used'
|
|
|
|
|
|
@freeze_time('2000-01-01T15:00')
|
|
def test_get_last_use_message_uses_most_recent_statistics():
|
|
template_statistics = [
|
|
{
|
|
'updated_at': '2000-01-01T12:00:00.000000+00:00'
|
|
},
|
|
{
|
|
'updated_at': '2000-01-01T09:00:00.000000+00:00'
|
|
},
|
|
]
|
|
assert get_last_use_message('My Template', template_statistics) == 'My Template was last used 3 hours ago'
|
|
|
|
|
|
@pytest.mark.parametrize('from_time, until_time, message', [
|
|
(datetime(2000, 1, 1, 12, 0), datetime(2000, 1, 1, 12, 0, 59), 'under a minute'),
|
|
(datetime(2000, 1, 1, 12, 0), datetime(2000, 1, 1, 12, 1), '1 minute'),
|
|
(datetime(2000, 1, 1, 12, 0), datetime(2000, 1, 1, 12, 2, 35), '2 minutes'),
|
|
(datetime(2000, 1, 1, 12, 0), datetime(2000, 1, 1, 12, 59), '59 minutes'),
|
|
(datetime(2000, 1, 1, 12, 0), datetime(2000, 1, 1, 13, 0), '1 hour'),
|
|
(datetime(2000, 1, 1, 12, 0), datetime(2000, 1, 1, 14, 0), '2 hours'),
|
|
(datetime(2000, 1, 1, 12, 0), datetime(2000, 1, 2, 11, 59), '23 hours'),
|
|
(datetime(2000, 1, 1, 12, 0), datetime(2000, 1, 2, 12, 0), '1 day'),
|
|
(datetime(2000, 1, 1, 12, 0), datetime(2000, 1, 3, 14, 0), '2 days'),
|
|
])
|
|
def test_get_human_readable_delta(from_time, until_time, message):
|
|
assert get_human_readable_delta(from_time, until_time) == message
|