mirror of
https://github.com/GSA/notifications-admin.git
synced 2026-07-09 02:44:10 -04:00
87f5a9e124
When viewing a letter template, there is a button to edit the letter contact block. This should take the user to the page to edit the letter contact block, but if a service has not set any letter contact blocks, the button was returning a 404 error. The code has now been changed so that if the service has no letter contact blocks the edit button will link to the page to add a letter contact block. Pivotal story: https://www.pivotaltracker.com/story/show/152881444
1289 lines
38 KiB
Python
1289 lines
38 KiB
Python
from datetime import datetime
|
||
from unittest.mock import Mock, ANY
|
||
|
||
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.conftest import (
|
||
mock_get_service_email_template,
|
||
mock_get_service_letter_template,
|
||
mock_get_service_template,
|
||
normalize_spaces,
|
||
SERVICE_ONE_ID,
|
||
active_user_with_permissions,
|
||
platform_admin_user,
|
||
)
|
||
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
|
||
|
||
|
||
@pytest.mark.parametrize('extra_args, expected_nav_links, expected_templates', [
|
||
(
|
||
{},
|
||
['Text message', 'Email'],
|
||
['sms_template_one', 'sms_template_two', 'email_template_one', 'email_template_two']
|
||
),
|
||
(
|
||
{'template_type': 'sms'},
|
||
['All', 'Email'],
|
||
['sms_template_one', 'sms_template_two'],
|
||
),
|
||
(
|
||
{'template_type': 'email'},
|
||
['All', 'Text message'],
|
||
['email_template_one', 'email_template_two'],
|
||
),
|
||
])
|
||
def test_should_show_page_for_choosing_a_template(
|
||
client_request,
|
||
mock_get_service_templates,
|
||
extra_args,
|
||
expected_nav_links,
|
||
expected_templates,
|
||
):
|
||
|
||
page = client_request.get(
|
||
'main.choose_template',
|
||
service_id=SERVICE_ONE_ID,
|
||
**extra_args
|
||
)
|
||
|
||
assert normalize_spaces(page.select('h1')[0].text) == 'Templates'
|
||
|
||
links_in_page = page.select('.pill a')
|
||
|
||
assert len(links_in_page) == len(expected_nav_links)
|
||
|
||
for index, expected_link in enumerate(expected_nav_links):
|
||
assert links_in_page[index].text.strip() == expected_link
|
||
|
||
template_links = page.select('.message-name a')
|
||
|
||
assert len(template_links) == len(expected_templates)
|
||
|
||
for index, expected_template in enumerate(expected_templates):
|
||
assert template_links[index].text.strip() == expected_template
|
||
|
||
mock_get_service_templates.assert_called_with(SERVICE_ONE_ID)
|
||
|
||
|
||
def test_should_not_show_template_nav_if_only_one_type_of_template(
|
||
client_request,
|
||
mock_get_service_templates_with_only_one_template,
|
||
):
|
||
|
||
page = client_request.get(
|
||
'main.choose_template',
|
||
service_id=SERVICE_ONE_ID,
|
||
)
|
||
|
||
assert not page.select('.pill')
|
||
|
||
|
||
def test_should_show_page_for_one_template(
|
||
logged_in_client,
|
||
mock_get_service_template,
|
||
service_one,
|
||
fake_uuid,
|
||
):
|
||
template_id = fake_uuid
|
||
response = logged_in_client.get(url_for(
|
||
'.edit_service_template',
|
||
service_id=service_one['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_one['id'], template_id)
|
||
|
||
|
||
@pytest.mark.parametrize('permissions, links_to_be_shown', [
|
||
(
|
||
['view_activity'],
|
||
[]
|
||
),
|
||
(
|
||
['manage_templates'],
|
||
['.edit_service_template']
|
||
),
|
||
(
|
||
['send_texts', 'send_emails', 'send_letters'],
|
||
['.send_messages', '.set_sender']
|
||
),
|
||
(
|
||
['send_texts', 'send_emails', 'send_letters', 'manage_templates'],
|
||
['.send_messages', '.set_sender', '.edit_service_template']
|
||
),
|
||
])
|
||
def test_should_be_able_to_view_a_template_with_links(
|
||
client,
|
||
mock_get_service_template,
|
||
active_user_with_permissions,
|
||
single_letter_contact_block,
|
||
mocker,
|
||
service_one,
|
||
fake_uuid,
|
||
permissions,
|
||
links_to_be_shown,
|
||
):
|
||
active_user_with_permissions._permissions[service_one['id']] = permissions
|
||
client.login(active_user_with_permissions, mocker, service_one)
|
||
|
||
response = client.get(url_for(
|
||
'.view_template',
|
||
service_id=service_one['id'],
|
||
template_id=fake_uuid
|
||
))
|
||
|
||
assert response.status_code == 200
|
||
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
|
||
links_in_page = page.select('.pill-separate-item')
|
||
|
||
assert len(links_in_page) == len(links_to_be_shown)
|
||
|
||
for index, link_to_be_shown in enumerate(links_to_be_shown):
|
||
assert links_in_page[index]['href'] == url_for(
|
||
link_to_be_shown,
|
||
service_id=service_one['id'],
|
||
template_id=fake_uuid,
|
||
)
|
||
|
||
|
||
def test_should_show_template_id_on_template_page(
|
||
logged_in_client,
|
||
mock_get_service_template,
|
||
service_one,
|
||
fake_uuid,
|
||
):
|
||
|
||
response = logged_in_client.get(url_for(
|
||
'.view_template',
|
||
service_id=service_one['id'],
|
||
template_id=fake_uuid))
|
||
|
||
assert response.status_code == 200
|
||
|
||
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
|
||
assert page.select('.api-key-key')[0].text == fake_uuid
|
||
|
||
|
||
def test_should_show_sms_template_with_downgraded_unicode_characters(
|
||
logged_in_client,
|
||
mocker,
|
||
service_one,
|
||
single_letter_contact_block,
|
||
fake_uuid,
|
||
):
|
||
msg = 'here:\tare some “fancy quotes” and zero\u200Bwidth\u200Bspaces'
|
||
rendered_msg = 'here: are some "fancy quotes" and zerowidthspaces'
|
||
|
||
mocker.patch(
|
||
'app.service_api_client.get_service_template',
|
||
return_value={'data': template_json(service_one['id'], fake_uuid, type_='sms', content=msg)}
|
||
)
|
||
|
||
template_id = fake_uuid
|
||
response = logged_in_client.get(url_for(
|
||
'.view_template',
|
||
service_id=service_one['id'],
|
||
template_id=template_id))
|
||
|
||
assert response.status_code == 200
|
||
assert rendered_msg in response.get_data(as_text=True)
|
||
|
||
|
||
def test_should_let_letter_contact_block_be_edited_if_a_letter_contact_block_exists(
|
||
mocker,
|
||
mock_get_service_letter_template,
|
||
single_letter_contact_block,
|
||
client_request,
|
||
service_one,
|
||
fake_uuid,
|
||
):
|
||
service_one['permissions'].append('letter')
|
||
mocker.patch('app.main.views.templates.get_page_count_for_letter', return_value=1)
|
||
|
||
page = client_request.get(
|
||
'main.view_template',
|
||
service_id=SERVICE_ONE_ID,
|
||
template_id=fake_uuid
|
||
)
|
||
|
||
assert page.find('a', {'class': 'edit-template-link-letter-contact'})['href'] == url_for(
|
||
'.service_edit_letter_contact',
|
||
service_id=service_one['id'],
|
||
letter_contact_id='1234',
|
||
from_template=fake_uuid)
|
||
|
||
|
||
def test_should_let_letter_contact_block_be_added_if_no_letter_contact_blocks_exist(
|
||
mocker,
|
||
mock_get_service_letter_template,
|
||
no_letter_contact_blocks,
|
||
client_request,
|
||
service_one,
|
||
fake_uuid,
|
||
):
|
||
service_one['permissions'].append('letter')
|
||
mocker.patch('app.main.views.templates.get_page_count_for_letter', return_value=1)
|
||
|
||
page = client_request.get(
|
||
'main.view_template',
|
||
service_id=SERVICE_ONE_ID,
|
||
template_id=fake_uuid
|
||
)
|
||
|
||
assert page.find('a', {'class': 'edit-template-link-letter-contact'})['href'] == url_for(
|
||
'.service_add_letter_contact',
|
||
service_id=service_one['id'],
|
||
from_template=fake_uuid)
|
||
|
||
|
||
def test_should_show_page_template_with_priority_select_if_platform_admin(
|
||
logged_in_platform_admin_client,
|
||
platform_admin_user,
|
||
mocker,
|
||
mock_get_service_template,
|
||
fake_uuid,
|
||
):
|
||
mocker.patch('app.user_api_client.get_users_for_service', return_value=[platform_admin_user])
|
||
template_id = fake_uuid
|
||
response = logged_in_platform_admin_client.get(url_for(
|
||
'.edit_service_template',
|
||
service_id='1234',
|
||
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('1234', template_id)
|
||
|
||
|
||
@pytest.mark.parametrize('filetype', ['pdf', 'png'])
|
||
@pytest.mark.parametrize('view, extra_view_args', [
|
||
('.view_letter_template_preview', {}),
|
||
('.view_template_version_preview', {'version': 1}),
|
||
])
|
||
def test_should_show_preview_letter_templates(
|
||
view,
|
||
extra_view_args,
|
||
filetype,
|
||
logged_in_client,
|
||
mock_get_service_email_template,
|
||
service_one,
|
||
fake_uuid,
|
||
mocker
|
||
):
|
||
mocked_preview = mocker.patch(
|
||
'app.main.views.templates.TemplatePreview.from_database_object',
|
||
return_value='foo'
|
||
)
|
||
|
||
service_id, template_id = service_one['id'], fake_uuid
|
||
|
||
response = logged_in_client.get(url_for(
|
||
view,
|
||
service_id=service_id,
|
||
template_id=template_id,
|
||
filetype=filetype,
|
||
**extra_view_args
|
||
))
|
||
|
||
assert response.status_code == 200
|
||
assert response.get_data(as_text=True) == 'foo'
|
||
mock_get_service_email_template.assert_called_with(service_id, template_id, **extra_view_args)
|
||
assert mocked_preview.call_args[0][0]['id'] == template_id
|
||
assert mocked_preview.call_args[0][0]['service'] == service_id
|
||
assert mocked_preview.call_args[0][1] == filetype
|
||
|
||
|
||
def test_dont_show_preview_letter_templates_for_bad_filetype(
|
||
logged_in_client,
|
||
mock_get_service_template,
|
||
service_one,
|
||
fake_uuid
|
||
):
|
||
resp = logged_in_client.get(
|
||
url_for(
|
||
'.view_letter_template_preview',
|
||
service_id=service_one['id'],
|
||
template_id=fake_uuid,
|
||
filetype='blah'
|
||
)
|
||
)
|
||
assert resp.status_code == 404
|
||
assert mock_get_service_template.called is False
|
||
|
||
|
||
@pytest.mark.parametrize('type_of_template', ['email', 'sms'])
|
||
def test_should_not_allow_creation_of_template_through_form_without_correct_permission(
|
||
logged_in_client,
|
||
service_one,
|
||
mocker,
|
||
type_of_template,
|
||
):
|
||
service_one['permissions'] = []
|
||
template_description = {'sms': 'text messages', 'email': 'emails'}
|
||
|
||
response = logged_in_client.post(url_for(
|
||
'.add_template_by_type',
|
||
service_id=service_one['id']),
|
||
data={'template_type': type_of_template},
|
||
follow_redirects=True)
|
||
|
||
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
|
||
|
||
assert response.status_code == 200
|
||
assert page.select('main p')[0].text.strip() == \
|
||
"Sending {} has been disabled for your service.".format(template_description[type_of_template])
|
||
assert page.select(".page-footer-back-link")[0].text == "Back to add new template"
|
||
assert page.select(".page-footer-back-link")[0]['href'] == url_for(
|
||
'.add_template_by_type',
|
||
service_id=service_one['id'],
|
||
template_id='0',
|
||
)
|
||
|
||
|
||
@pytest.mark.parametrize('type_of_template', ['email', 'sms'])
|
||
def test_should_not_allow_creation_of_a_template_without_correct_permission(
|
||
logged_in_client,
|
||
service_one,
|
||
mocker,
|
||
type_of_template,
|
||
):
|
||
service_one['permissions'] = []
|
||
template_description = {'sms': 'text messages', 'email': 'emails'}
|
||
|
||
response = logged_in_client.get(url_for(
|
||
'.add_service_template',
|
||
service_id=service_one['id'],
|
||
template_type=type_of_template),
|
||
follow_redirects=True)
|
||
|
||
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
|
||
|
||
assert response.status_code == 200
|
||
assert page.select('main p')[0].text.strip() == \
|
||
"Sending {} has been disabled for your service.".format(template_description[type_of_template])
|
||
assert page.select(".page-footer-back-link")[0].text == "Back to templates"
|
||
assert page.select(".page-footer-back-link")[0]['href'] == url_for(
|
||
'.choose_template',
|
||
service_id=service_one['id'],
|
||
template_id='0',
|
||
)
|
||
|
||
|
||
@pytest.mark.parametrize('fixture, expected_status_code', [
|
||
(mock_get_service_email_template, 200),
|
||
(mock_get_service_template, 200),
|
||
(mock_get_service_letter_template, 302),
|
||
])
|
||
def test_should_redirect_to_one_off_if_template_type_is_letter(
|
||
logged_in_client,
|
||
active_user_with_permissions,
|
||
multiple_reply_to_email_addresses,
|
||
multiple_sms_senders,
|
||
service_one,
|
||
fake_uuid,
|
||
mocker,
|
||
fixture,
|
||
expected_status_code
|
||
):
|
||
fixture(mocker)
|
||
|
||
page = logged_in_client.get(
|
||
url_for('.set_sender', service_id=service_one['id'], template_id=fake_uuid)
|
||
)
|
||
|
||
assert page.status_code == expected_status_code
|
||
|
||
|
||
def test_should_redirect_when_saving_a_template(
|
||
logged_in_client,
|
||
active_user_with_permissions,
|
||
mocker,
|
||
mock_get_service_template,
|
||
mock_update_service_template,
|
||
fake_uuid,
|
||
):
|
||
service = create_sample_service(active_user_with_permissions)
|
||
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')
|
||
|
||
|
||
def test_should_edit_content_when_process_type_is_priority_not_platform_admin(
|
||
logged_in_client,
|
||
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)
|
||
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_not_allow_template_edits_without_correct_permission(
|
||
logged_in_client,
|
||
mock_get_service_template,
|
||
service_one,
|
||
fake_uuid,
|
||
):
|
||
template_id = fake_uuid
|
||
service_one['permissions'] = ['email']
|
||
|
||
response = logged_in_client.get(url_for(
|
||
'.edit_service_template',
|
||
service_id=service_one['id'],
|
||
template_id=template_id),
|
||
follow_redirects=True)
|
||
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
|
||
|
||
assert response.status_code == 200
|
||
assert page.select('main p')[0].text.strip() == "Sending text messages has been disabled for your service."
|
||
assert page.select(".page-footer-back-link")[0].text == "Back to the template"
|
||
assert page.select(".page-footer-back-link")[0]['href'] == url_for(
|
||
'.view_template',
|
||
service_id=service_one['id'],
|
||
template_id=template_id,
|
||
)
|
||
|
||
|
||
def test_should_403_when_edit_template_with_process_type_of_priority_for_non_platform_admin(
|
||
client,
|
||
active_user_with_permissions,
|
||
mocker,
|
||
mock_get_service_template,
|
||
mock_update_service_template,
|
||
fake_uuid,
|
||
):
|
||
service = create_sample_service(active_user_with_permissions)
|
||
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(
|
||
client,
|
||
active_user_with_permissions,
|
||
mocker,
|
||
mock_get_service_template,
|
||
mock_update_service_template,
|
||
fake_uuid,
|
||
):
|
||
service = create_sample_service(active_user_with_permissions)
|
||
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
|
||
|
||
|
||
@pytest.mark.parametrize('template_mock, expected_paragraphs', [
|
||
(
|
||
mock_get_service_email_template,
|
||
[
|
||
'You removed ((date))',
|
||
'You added ((name))',
|
||
'When you send messages using this template you’ll need 3 columns of data:',
|
||
]
|
||
),
|
||
(
|
||
mock_get_service_letter_template,
|
||
[
|
||
'You removed ((date))',
|
||
'You added ((name))',
|
||
'When you send messages using this template you’ll need 9 columns of data:',
|
||
]
|
||
),
|
||
])
|
||
def test_should_show_interstitial_when_making_breaking_change(
|
||
logged_in_client,
|
||
api_user_active,
|
||
mock_login,
|
||
mock_update_service_template,
|
||
mock_get_user,
|
||
mock_get_service,
|
||
mock_get_user_by_email,
|
||
mock_has_permissions,
|
||
fake_uuid,
|
||
mocker,
|
||
template_mock,
|
||
expected_paragraphs,
|
||
):
|
||
template_mock(
|
||
mocker,
|
||
subject="Your ((thing)) is due soon",
|
||
content="Your vehicle tax expires on ((date))",
|
||
)
|
||
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 lets talk about ((thing))",
|
||
'template_type': 'email',
|
||
'subject': 'reminder \'" <span> & ((name))',
|
||
'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 index, p in enumerate(expected_paragraphs):
|
||
assert normalize_spaces(page.select('main p')[index].text) == p
|
||
|
||
for key, value in {
|
||
'name': 'new name',
|
||
'subject': 'reminder \'" <span> & ((name))',
|
||
'template_content': 'hello lets talk about ((thing))',
|
||
'confirm': 'true'
|
||
}.items():
|
||
assert page.find('input', {'name': key})['value'] == value
|
||
|
||
# BeautifulSoup returns the value attribute as unencoded, let’s make
|
||
# sure that it is properly encoded in the HTML
|
||
assert str(page.find('input', {'name': 'subject'})) == (
|
||
"""<input name="subject" type="hidden" value="reminder '" <span> & ((name))"/>"""
|
||
)
|
||
|
||
|
||
def test_removing_placeholders_is_not_a_breaking_change(
|
||
logged_in_client,
|
||
mock_get_service_email_template,
|
||
mock_update_service_template,
|
||
mock_has_permissions,
|
||
fake_uuid,
|
||
):
|
||
service_id = fake_uuid
|
||
template_id = fake_uuid
|
||
existing_template = mock_get_service_email_template(0, 0)['data']
|
||
response = logged_in_client.post(
|
||
url_for(
|
||
'.edit_service_template',
|
||
service_id=service_id,
|
||
template_id=template_id
|
||
),
|
||
data={
|
||
'name': existing_template['name'],
|
||
'template_content': "no placeholders",
|
||
'subject': existing_template['subject'],
|
||
}
|
||
)
|
||
|
||
assert response.status_code == 302
|
||
assert response.location == url_for(
|
||
'main.view_template',
|
||
service_id=service_id,
|
||
template_id=template_id,
|
||
_external=True,
|
||
)
|
||
|
||
|
||
def test_should_not_create_too_big_template(
|
||
logged_in_client,
|
||
service_one,
|
||
mock_get_service_template,
|
||
mock_create_service_template_content_too_big,
|
||
fake_uuid,
|
||
):
|
||
template_type = 'sms'
|
||
data = {
|
||
'name': "new name",
|
||
'template_content': "template content",
|
||
'template_type': template_type,
|
||
'service': service_one['id'],
|
||
'process_type': 'normal'
|
||
}
|
||
resp = logged_in_client.post(url_for(
|
||
'.add_service_template',
|
||
service_id=service_one['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(
|
||
logged_in_client,
|
||
service_one,
|
||
mock_get_service_template,
|
||
mock_update_service_template_400_content_too_big,
|
||
fake_uuid,
|
||
):
|
||
template_id = fake_uuid
|
||
data = {
|
||
'id': fake_uuid,
|
||
'name': "new name",
|
||
'template_content': "template content",
|
||
'service': service_one['id'],
|
||
'template_type': 'sms',
|
||
'process_type': 'normal'
|
||
}
|
||
resp = logged_in_client.post(url_for(
|
||
'.edit_service_template',
|
||
service_id=service_one['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(
|
||
logged_in_client,
|
||
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,
|
||
):
|
||
service_id = fake_uuid
|
||
template_id = fake_uuid
|
||
name = "new name"
|
||
content = "template <em>content</em> with & entity ((thing)) ((date))"
|
||
subject = "subject & entity"
|
||
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(
|
||
client_request,
|
||
mock_get_service_template,
|
||
mocker,
|
||
fake_uuid
|
||
):
|
||
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'):
|
||
page = client_request.get(
|
||
'.delete_service_template',
|
||
service_id=SERVICE_ONE_ID,
|
||
template_id=fake_uuid,
|
||
_test_page_title=False,
|
||
)
|
||
assert page.h1.text == 'Are you sure you want to delete Two week reminder?'
|
||
assert normalize_spaces(page.select('.banner-dangerous p')[0].text) == (
|
||
'It was last used 10 minutes ago'
|
||
)
|
||
assert normalize_spaces(page.select('.sms-message-wrapper')[0].text) == (
|
||
'service one: Template <em>content</em> with & entity'
|
||
)
|
||
mock_get_service_template.assert_called_with(SERVICE_ONE_ID, fake_uuid)
|
||
|
||
|
||
def test_should_show_delete_template_page_with_time_block_for_empty_notification(
|
||
client_request,
|
||
mock_get_service_template,
|
||
mocker,
|
||
fake_uuid
|
||
):
|
||
with freeze_time('2012-01-08 12:00:00'):
|
||
template = template_json('1234', '1234', "Test template", "sms", "Something very interesting")
|
||
single_notification_json('1234', template=template)
|
||
mocker.patch('app.template_statistics_client.get_template_statistics_for_template',
|
||
return_value=None)
|
||
|
||
with freeze_time('2012-01-01 11:00:00'):
|
||
page = client_request.get(
|
||
'.delete_service_template',
|
||
service_id=SERVICE_ONE_ID,
|
||
template_id=fake_uuid,
|
||
_test_page_title=False,
|
||
)
|
||
assert page.h1.text == 'Are you sure you want to delete Two week reminder?'
|
||
assert normalize_spaces(page.select('.banner-dangerous p')[0].text) == (
|
||
'It was last used more than seven days ago'
|
||
)
|
||
assert normalize_spaces(page.select('.sms-message-wrapper')[0].text) == (
|
||
'service one: Template <em>content</em> with & entity'
|
||
)
|
||
mock_get_service_template.assert_called_with(SERVICE_ONE_ID, fake_uuid)
|
||
|
||
|
||
def test_should_show_delete_template_page_with_never_used_block(
|
||
client_request,
|
||
mock_get_service_template,
|
||
fake_uuid,
|
||
mocker,
|
||
):
|
||
mocker.patch(
|
||
'app.template_statistics_client.get_template_statistics_for_template',
|
||
side_effect=HTTPError(response=Mock(status_code=404), message="Default message")
|
||
)
|
||
page = client_request.get(
|
||
'.delete_service_template',
|
||
service_id=SERVICE_ONE_ID,
|
||
template_id=fake_uuid,
|
||
_test_page_title=False,
|
||
)
|
||
assert page.h1.text == 'Are you sure you want to delete Two week reminder?'
|
||
assert not page.select('.banner-dangerous p')
|
||
assert normalize_spaces(page.select('.sms-message-wrapper')[0].text) == (
|
||
'service one: Template <em>content</em> with & entity'
|
||
)
|
||
mock_get_service_template.assert_called_with(SERVICE_ONE_ID, fake_uuid)
|
||
|
||
|
||
def test_should_redirect_when_deleting_a_template(
|
||
logged_in_client,
|
||
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,
|
||
):
|
||
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, _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(
|
||
logged_in_client,
|
||
api_user_active,
|
||
mock_login,
|
||
mock_get_service,
|
||
mock_get_deleted_template,
|
||
single_letter_contact_block,
|
||
mock_get_user,
|
||
mock_get_user_by_email,
|
||
mock_has_permissions,
|
||
fake_uuid,
|
||
):
|
||
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
|
||
|
||
content = response.get_data(as_text=True)
|
||
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
|
||
assert url_for("main.edit_service_template", 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 page.select('p.hint')[0].text.strip() == 'This template was deleted today at 3:00pm.'
|
||
assert 'Delete this template' not in page.select_one('main').text
|
||
|
||
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_,
|
||
client,
|
||
api_user_active,
|
||
service_one,
|
||
mock_get_service_template,
|
||
mock_get_template_statistics_for_template,
|
||
fake_uuid,
|
||
):
|
||
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')
|
||
validate_route_permission(
|
||
mocker,
|
||
app_,
|
||
"GET",
|
||
200,
|
||
url_for(
|
||
'main.choose_template',
|
||
service_id=service_one['id'],
|
||
),
|
||
['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_,
|
||
client,
|
||
api_user_active,
|
||
service_one,
|
||
mock_get_service_template,
|
||
mock_get_template_statistics_for_template,
|
||
fake_uuid,
|
||
):
|
||
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
|
||
|
||
|
||
def test_can_create_email_template_with_emoji(
|
||
logged_in_client,
|
||
service_one,
|
||
mock_create_service_template
|
||
):
|
||
data = {
|
||
'name': "new name",
|
||
'subject': "Food incoming!",
|
||
'template_content': "here's a burrito 🌯",
|
||
'template_type': 'email',
|
||
'service': service_one['id'],
|
||
'process_type': 'normal'
|
||
}
|
||
resp = logged_in_client.post(url_for(
|
||
'.add_service_template',
|
||
service_id=service_one['id'],
|
||
template_type='email'
|
||
), data=data)
|
||
|
||
assert resp.status_code == 302
|
||
|
||
|
||
def test_should_not_create_sms_template_with_emoji(
|
||
logged_in_client,
|
||
service_one,
|
||
mock_create_service_template
|
||
):
|
||
data = {
|
||
'name': "new name",
|
||
'template_content': "here are some noodles 🍜",
|
||
'template_type': 'sms',
|
||
'service': service_one['id'],
|
||
'process_type': 'normal'
|
||
}
|
||
resp = logged_in_client.post(url_for(
|
||
'.add_service_template',
|
||
service_id=service_one['id'],
|
||
template_type='sms'
|
||
), data=data)
|
||
|
||
assert resp.status_code == 200
|
||
assert "You can’t use 🍜 in text messages." in resp.get_data(as_text=True)
|
||
|
||
|
||
def test_should_not_update_sms_template_with_emoji(
|
||
logged_in_client,
|
||
service_one,
|
||
mock_get_service_template,
|
||
mock_update_service_template,
|
||
fake_uuid,
|
||
):
|
||
data = {
|
||
'id': fake_uuid,
|
||
'name': "new name",
|
||
'template_content': "here's a burger 🍔",
|
||
'service': service_one['id'],
|
||
'template_type': 'sms',
|
||
'process_type': 'normal'
|
||
}
|
||
resp = logged_in_client.post(url_for(
|
||
'.edit_service_template',
|
||
service_id=service_one['id'],
|
||
template_id=fake_uuid), data=data)
|
||
|
||
assert resp.status_code == 200
|
||
assert "You can’t use 🍔 in text messages." in resp.get_data(as_text=True)
|
||
|
||
|
||
def test_should_create_sms_template_without_downgrading_unicode_characters(
|
||
logged_in_client,
|
||
service_one,
|
||
mock_create_service_template
|
||
):
|
||
msg = 'here:\tare some “fancy quotes” and non\u200Bbreaking\u200Bspaces'
|
||
|
||
data = {
|
||
'name': "new name",
|
||
'template_content': msg,
|
||
'template_type': 'sms',
|
||
'service': service_one['id'],
|
||
'process_type': 'normal'
|
||
}
|
||
resp = logged_in_client.post(url_for(
|
||
'.add_service_template',
|
||
service_id=service_one['id'],
|
||
template_type='sms'
|
||
), data=data)
|
||
|
||
mock_create_service_template.assert_called_with(
|
||
ANY, # name
|
||
ANY, # type
|
||
msg, # content
|
||
ANY, # service_id
|
||
ANY, # subject
|
||
ANY # process_type
|
||
)
|
||
assert resp.status_code == 302
|
||
|
||
|
||
def test_should_show_template_as_first_page_of_tour(
|
||
client_request,
|
||
mock_get_service_template,
|
||
service_one,
|
||
fake_uuid,
|
||
):
|
||
|
||
page = client_request.get(
|
||
'main.start_tour',
|
||
service_id=SERVICE_ONE_ID,
|
||
template_id=fake_uuid,
|
||
)
|
||
|
||
assert normalize_spaces(
|
||
page.select('.banner-tour .heading-medium')[0].text
|
||
) == (
|
||
'Try sending yourself this example'
|
||
)
|
||
|
||
assert normalize_spaces(
|
||
page.select('.sms-message-wrapper')[0].text
|
||
) == (
|
||
'service one: Template <em>content</em> with & entity'
|
||
)
|
||
|
||
assert page.select('a.button')[0]['href'] == url_for(
|
||
'.send_test', service_id=SERVICE_ONE_ID, template_id=fake_uuid, help=2
|
||
)
|
||
|
||
|
||
@pytest.mark.parametrize('template_mock', [
|
||
mock_get_service_email_template,
|
||
mock_get_service_letter_template,
|
||
])
|
||
def test_cant_see_email_template_in_tour(
|
||
client_request,
|
||
fake_uuid,
|
||
mocker,
|
||
template_mock,
|
||
):
|
||
|
||
template_mock(mocker)
|
||
|
||
client_request.get(
|
||
'main.start_tour',
|
||
service_id=SERVICE_ONE_ID,
|
||
template_id=fake_uuid,
|
||
_expected_status=404,
|
||
)
|
||
|
||
|
||
def test_should_show_message_before_redacting_template(
|
||
client_request,
|
||
mock_get_service_template,
|
||
service_one,
|
||
fake_uuid,
|
||
):
|
||
|
||
page = client_request.get(
|
||
'main.redact_template',
|
||
service_id=SERVICE_ONE_ID,
|
||
template_id=fake_uuid,
|
||
_test_page_title=False,
|
||
)
|
||
|
||
assert (
|
||
'Are you sure you want to hide personalisation after sending?'
|
||
) in page.select('.banner-dangerous')[0].text
|
||
|
||
form = page.select('.banner-dangerous form')[0]
|
||
|
||
assert 'action' not in form
|
||
assert form['method'] == 'post'
|
||
|
||
|
||
def test_should_show_redact_template(
|
||
client_request,
|
||
mock_get_service_template,
|
||
mock_redact_template,
|
||
single_letter_contact_block,
|
||
service_one,
|
||
fake_uuid,
|
||
):
|
||
|
||
page = client_request.post(
|
||
'main.redact_template',
|
||
service_id=SERVICE_ONE_ID,
|
||
template_id=fake_uuid,
|
||
_follow_redirects=True,
|
||
)
|
||
|
||
assert normalize_spaces(page.select('.banner-default-with-tick')[0].text) == (
|
||
'Personalised content will be hidden for messages sent with this template'
|
||
)
|
||
|
||
mock_redact_template.assert_called_once_with(SERVICE_ONE_ID, fake_uuid)
|
||
|
||
|
||
def test_should_show_hint_once_template_redacted(
|
||
client_request,
|
||
mocker,
|
||
service_one,
|
||
fake_uuid,
|
||
):
|
||
|
||
mock_get_service_email_template(mocker, redact_personalisation=True)
|
||
|
||
page = client_request.get(
|
||
'main.view_template',
|
||
service_id=SERVICE_ONE_ID,
|
||
template_id=fake_uuid,
|
||
)
|
||
|
||
assert page.select('.hint')[0].text == 'Personalisation is hidden after sending'
|
||
|
||
|
||
@pytest.mark.parametrize('test_user, template_mock, expected_response_code', [
|
||
(
|
||
active_user_with_permissions,
|
||
mock_get_service_letter_template,
|
||
403
|
||
),
|
||
(
|
||
platform_admin_user,
|
||
mock_get_service_template,
|
||
404
|
||
),
|
||
(
|
||
platform_admin_user,
|
||
mock_get_service_email_template,
|
||
404
|
||
),
|
||
(
|
||
platform_admin_user,
|
||
mock_get_service_letter_template,
|
||
200
|
||
),
|
||
])
|
||
def test_should_show_letter_template_as_dvla_markup(
|
||
client,
|
||
mocker,
|
||
service_one,
|
||
fake_uuid,
|
||
mock_get_service,
|
||
test_user,
|
||
template_mock,
|
||
expected_response_code,
|
||
):
|
||
|
||
client.login(test_user(fake_uuid), mocker, service_one)
|
||
template_mock(mocker)
|
||
|
||
response = client.get(url_for(
|
||
'.view_template_as_dvla_markup',
|
||
service_id=SERVICE_ONE_ID,
|
||
template_id=fake_uuid,
|
||
))
|
||
|
||
assert response.status_code == expected_response_code
|