mirror of
https://github.com/GSA/notifications-api.git
synced 2026-08-11 09:27:56 -04:00
7f918d7c48
When a template is archived, it should no longer belong to any folder. If we don’t do this it will make it very hard to delete folders later (because folders can only be deleted if they have no templates or folders inside them). We originally tried to check if the link between a template and folder should be removed with `if template.archived and template.folder:` instead of using `if template.archived:`. However, this caused issues because checking `template.folder` flushes the session. Since the session is no longer dirty, the versioning decorator doesn't work as expected and doesn't create a new row in `TemplateHistory`.
526 lines
18 KiB
Python
526 lines
18 KiB
Python
from datetime import datetime
|
|
|
|
from freezegun import freeze_time
|
|
from sqlalchemy.orm.exc import NoResultFound
|
|
import pytest
|
|
|
|
from app.dao.templates_dao import (
|
|
dao_create_template,
|
|
dao_get_template_by_id_and_service_id,
|
|
dao_get_all_templates_for_service,
|
|
dao_update_template,
|
|
dao_get_template_versions,
|
|
dao_get_multiple_template_details,
|
|
dao_redact_template, dao_update_template_reply_to
|
|
)
|
|
from app.models import (
|
|
Template,
|
|
TemplateFolder,
|
|
TemplateHistory,
|
|
TemplateRedacted
|
|
)
|
|
|
|
from tests.app.conftest import sample_template as create_sample_template
|
|
from tests.app.db import create_template, create_letter_contact
|
|
|
|
|
|
@pytest.mark.parametrize('template_type, subject', [
|
|
('sms', None),
|
|
('email', 'subject'),
|
|
('letter', 'subject'),
|
|
])
|
|
def test_create_template(sample_service, sample_user, template_type, subject):
|
|
data = {
|
|
'name': 'Sample Template',
|
|
'template_type': template_type,
|
|
'content': "Template content",
|
|
'service': sample_service,
|
|
'created_by': sample_user
|
|
}
|
|
if subject:
|
|
data.update({'subject': subject})
|
|
template = Template(**data)
|
|
dao_create_template(template)
|
|
|
|
assert Template.query.count() == 1
|
|
assert len(dao_get_all_templates_for_service(sample_service.id)) == 1
|
|
assert dao_get_all_templates_for_service(sample_service.id)[0].name == 'Sample Template'
|
|
assert dao_get_all_templates_for_service(sample_service.id)[0].process_type == 'normal'
|
|
|
|
|
|
def test_create_template_creates_redact_entry(sample_service):
|
|
assert TemplateRedacted.query.count() == 0
|
|
|
|
template = create_template(sample_service)
|
|
|
|
redacted = TemplateRedacted.query.one()
|
|
assert redacted.template_id == template.id
|
|
assert redacted.redact_personalisation is False
|
|
assert redacted.updated_by_id == sample_service.created_by_id
|
|
|
|
|
|
def test_create_template_with_reply_to(sample_service, sample_user):
|
|
letter_contact = create_letter_contact(sample_service, 'Edinburgh, ED1 1AA')
|
|
|
|
data = {
|
|
'name': 'Sample Template',
|
|
'template_type': "letter",
|
|
'content': "Template content",
|
|
'service': sample_service,
|
|
'created_by': sample_user,
|
|
'reply_to': letter_contact.id,
|
|
}
|
|
template = Template(**data)
|
|
dao_create_template(template)
|
|
|
|
assert dao_get_all_templates_for_service(sample_service.id)[0].reply_to == letter_contact.id
|
|
|
|
|
|
def test_update_template(sample_service, sample_user):
|
|
data = {
|
|
'name': 'Sample Template',
|
|
'template_type': "sms",
|
|
'content': "Template content",
|
|
'service': sample_service,
|
|
'created_by': sample_user
|
|
}
|
|
template = Template(**data)
|
|
dao_create_template(template)
|
|
created = dao_get_all_templates_for_service(sample_service.id)[0]
|
|
assert created.name == 'Sample Template'
|
|
|
|
created.name = 'new name'
|
|
dao_update_template(created)
|
|
assert dao_get_all_templates_for_service(sample_service.id)[0].name == 'new name'
|
|
|
|
|
|
def test_update_template_in_a_folder_to_archived(sample_service, sample_user):
|
|
template_data = {
|
|
'name': 'Sample Template',
|
|
'template_type': "sms",
|
|
'content': "Template content",
|
|
'service': sample_service,
|
|
'created_by': sample_user
|
|
}
|
|
template = Template(**template_data)
|
|
|
|
template_folder_data = {
|
|
'name': 'My Folder',
|
|
'service_id': sample_service.id,
|
|
}
|
|
template_folder = TemplateFolder(**template_folder_data)
|
|
|
|
template.folder = template_folder
|
|
dao_create_template(template)
|
|
|
|
template.archived = True
|
|
dao_update_template(template)
|
|
|
|
template_folder = TemplateFolder.query.one()
|
|
archived_template = Template.query.one()
|
|
|
|
assert template_folder
|
|
assert not archived_template.folder
|
|
|
|
|
|
def test_dao_update_template_reply_to_none_to_some(sample_service, sample_user):
|
|
letter_contact = create_letter_contact(sample_service, 'Edinburgh, ED1 1AA')
|
|
|
|
data = {
|
|
'name': 'Sample Template',
|
|
'template_type': "letter",
|
|
'content': "Template content",
|
|
'service': sample_service,
|
|
'created_by': sample_user,
|
|
}
|
|
template = Template(**data)
|
|
dao_create_template(template)
|
|
created = Template.query.get(template.id)
|
|
assert created.reply_to is None
|
|
assert created.service_letter_contact_id is None
|
|
|
|
dao_update_template_reply_to(template_id=template.id,
|
|
reply_to=letter_contact.id)
|
|
|
|
updated = Template.query.get(template.id)
|
|
assert updated.reply_to == letter_contact.id
|
|
assert updated.version == 2
|
|
assert updated.updated_at
|
|
|
|
template_history = TemplateHistory.query.filter_by(id=created.id, version=2).one()
|
|
assert template_history.service_letter_contact_id == letter_contact.id
|
|
assert template_history.updated_at == updated.updated_at
|
|
|
|
|
|
def test_dao_update_tempalte_reply_to_some_to_some(sample_service, sample_user):
|
|
letter_contact = create_letter_contact(sample_service, 'Edinburgh, ED1 1AA')
|
|
letter_contact_2 = create_letter_contact(sample_service, 'London, N1 1DE')
|
|
|
|
data = {
|
|
'name': 'Sample Template',
|
|
'template_type': "letter",
|
|
'content': "Template content",
|
|
'service': sample_service,
|
|
'created_by': sample_user,
|
|
'service_letter_contact_id': letter_contact.id
|
|
}
|
|
template = Template(**data)
|
|
dao_create_template(template)
|
|
created = Template.query.get(template.id)
|
|
dao_update_template_reply_to(template_id=created.id, reply_to=letter_contact_2.id)
|
|
updated = Template.query.get(template.id)
|
|
assert updated.reply_to == letter_contact_2.id
|
|
assert updated.version == 2
|
|
assert updated.updated_at
|
|
|
|
updated_history = TemplateHistory.query.filter_by(id=created.id, version=2).one()
|
|
assert updated_history.service_letter_contact_id == letter_contact_2.id
|
|
assert updated_history.updated_at == updated_history.updated_at
|
|
|
|
|
|
def test_dao_update_template_reply_to_some_to_none(sample_service, sample_user):
|
|
letter_contact = create_letter_contact(sample_service, 'Edinburgh, ED1 1AA')
|
|
data = {
|
|
'name': 'Sample Template',
|
|
'template_type': "letter",
|
|
'content': "Template content",
|
|
'service': sample_service,
|
|
'created_by': sample_user,
|
|
'service_letter_contact_id': letter_contact.id
|
|
}
|
|
template = Template(**data)
|
|
dao_create_template(template)
|
|
created = Template.query.get(template.id)
|
|
dao_update_template_reply_to(template_id=created.id, reply_to=None)
|
|
updated = Template.query.get(template.id)
|
|
assert updated.reply_to is None
|
|
assert updated.version == 2
|
|
assert updated.updated_at
|
|
|
|
history = TemplateHistory.query.filter_by(id=created.id, version=2).one()
|
|
assert history.service_letter_contact_id is None
|
|
assert history.updated_at == updated.updated_at
|
|
|
|
|
|
def test_redact_template(sample_template):
|
|
redacted = TemplateRedacted.query.one()
|
|
assert redacted.template_id == sample_template.id
|
|
assert redacted.redact_personalisation is False
|
|
|
|
time = datetime.now()
|
|
with freeze_time(time):
|
|
dao_redact_template(sample_template, sample_template.created_by_id)
|
|
|
|
assert redacted.redact_personalisation is True
|
|
assert redacted.updated_at == time
|
|
assert redacted.updated_by_id == sample_template.created_by_id
|
|
|
|
|
|
def test_get_all_templates_for_service(notify_db, notify_db_session, service_factory):
|
|
service_1 = service_factory.get('service 1', email_from='service.1')
|
|
service_2 = service_factory.get('service 2', email_from='service.2')
|
|
|
|
assert Template.query.count() == 2
|
|
assert len(dao_get_all_templates_for_service(service_1.id)) == 1
|
|
assert len(dao_get_all_templates_for_service(service_2.id)) == 1
|
|
|
|
create_sample_template(
|
|
notify_db,
|
|
notify_db_session,
|
|
template_name='Sample Template 1',
|
|
template_type="sms",
|
|
content="Template content",
|
|
service=service_1
|
|
)
|
|
create_sample_template(
|
|
notify_db,
|
|
notify_db_session,
|
|
template_name='Sample Template 2',
|
|
template_type="sms",
|
|
content="Template content",
|
|
service=service_1
|
|
)
|
|
create_sample_template(
|
|
notify_db,
|
|
notify_db_session,
|
|
template_name='Sample Template 3',
|
|
template_type="sms",
|
|
content="Template content",
|
|
service=service_2
|
|
)
|
|
|
|
assert Template.query.count() == 5
|
|
assert len(dao_get_all_templates_for_service(service_1.id)) == 3
|
|
assert len(dao_get_all_templates_for_service(service_2.id)) == 2
|
|
|
|
|
|
def test_get_all_templates_for_service_is_alphabetised(notify_db, notify_db_session, sample_service):
|
|
create_sample_template(
|
|
notify_db,
|
|
notify_db_session,
|
|
template_name='Sample Template 1',
|
|
template_type="sms",
|
|
content="Template content",
|
|
service=sample_service
|
|
)
|
|
template_2 = create_sample_template(
|
|
notify_db,
|
|
notify_db_session,
|
|
template_name='Sample Template 2',
|
|
template_type="sms",
|
|
content="Template content",
|
|
service=sample_service
|
|
)
|
|
create_sample_template(
|
|
notify_db,
|
|
notify_db_session,
|
|
template_name='Sample Template 3',
|
|
template_type="sms",
|
|
content="Template content",
|
|
service=sample_service
|
|
)
|
|
|
|
assert Template.query.count() == 3
|
|
assert dao_get_all_templates_for_service(sample_service.id)[0].name == 'Sample Template 1'
|
|
assert dao_get_all_templates_for_service(sample_service.id)[1].name == 'Sample Template 2'
|
|
assert dao_get_all_templates_for_service(sample_service.id)[2].name == 'Sample Template 3'
|
|
|
|
template_2.name = 'AAAAA Sample Template 2'
|
|
dao_update_template(template_2)
|
|
assert dao_get_all_templates_for_service(sample_service.id)[0].name == 'AAAAA Sample Template 2'
|
|
assert dao_get_all_templates_for_service(sample_service.id)[1].name == 'Sample Template 1'
|
|
|
|
|
|
def test_get_all_returns_empty_list_if_no_templates(sample_service):
|
|
assert Template.query.count() == 0
|
|
assert len(dao_get_all_templates_for_service(sample_service.id)) == 0
|
|
|
|
|
|
def test_get_all_templates_ignores_archived_templates(notify_db, notify_db_session, sample_service):
|
|
normal_template = create_sample_template(
|
|
notify_db,
|
|
notify_db_session,
|
|
template_name='Normal Template',
|
|
service=sample_service,
|
|
archived=False
|
|
)
|
|
archived_template = create_sample_template(
|
|
notify_db,
|
|
notify_db_session,
|
|
template_name='Archived Template',
|
|
service=sample_service
|
|
)
|
|
# sample_template fixture uses dao, which forces archived = False at creation.
|
|
archived_template.archived = True
|
|
dao_update_template(archived_template)
|
|
|
|
templates = dao_get_all_templates_for_service(sample_service.id)
|
|
|
|
assert len(templates) == 1
|
|
assert templates[0] == normal_template
|
|
|
|
|
|
def test_get_all_templates_ignores_hidden_templates(notify_db, notify_db_session, sample_service):
|
|
normal_template = create_sample_template(
|
|
notify_db,
|
|
notify_db_session,
|
|
template_name='Normal Template',
|
|
service=sample_service,
|
|
archived=False
|
|
)
|
|
|
|
create_sample_template(
|
|
notify_db,
|
|
notify_db_session,
|
|
template_name='Hidden Template',
|
|
hidden=True,
|
|
service=sample_service
|
|
)
|
|
|
|
templates = dao_get_all_templates_for_service(sample_service.id)
|
|
|
|
assert len(templates) == 1
|
|
assert templates[0] == normal_template
|
|
|
|
|
|
def test_get_template_by_id_and_service(notify_db, notify_db_session, sample_service):
|
|
sample_template = create_sample_template(
|
|
notify_db,
|
|
notify_db_session,
|
|
template_name='Test Template',
|
|
service=sample_service)
|
|
template = dao_get_template_by_id_and_service_id(
|
|
template_id=sample_template.id,
|
|
service_id=sample_service.id)
|
|
assert template.id == sample_template.id
|
|
assert template.name == 'Test Template'
|
|
assert template.version == sample_template.version
|
|
assert not template.redact_personalisation
|
|
|
|
|
|
def test_get_template_by_id_and_service_returns_none_for_hidden_templates(notify_db, notify_db_session, sample_service):
|
|
sample_template = create_sample_template(
|
|
notify_db,
|
|
notify_db_session,
|
|
template_name='Test Template',
|
|
hidden=True,
|
|
service=sample_service
|
|
)
|
|
|
|
with pytest.raises(NoResultFound):
|
|
dao_get_template_by_id_and_service_id(
|
|
template_id=sample_template.id,
|
|
service_id=sample_service.id
|
|
)
|
|
|
|
|
|
def test_get_template_version_returns_none_for_hidden_templates(notify_db, notify_db_session, sample_service):
|
|
sample_template = create_sample_template(
|
|
notify_db,
|
|
notify_db_session,
|
|
template_name='Test Template',
|
|
hidden=True,
|
|
service=sample_service
|
|
)
|
|
|
|
with pytest.raises(NoResultFound):
|
|
dao_get_template_by_id_and_service_id(
|
|
sample_template.id,
|
|
sample_service.id,
|
|
'1'
|
|
)
|
|
|
|
|
|
def test_get_template_by_id_and_service_returns_none_if_no_template(sample_service, fake_uuid):
|
|
with pytest.raises(NoResultFound) as e:
|
|
dao_get_template_by_id_and_service_id(template_id=fake_uuid, service_id=sample_service.id)
|
|
assert 'No row was found for one' in str(e.value)
|
|
|
|
|
|
def test_create_template_creates_a_history_record_with_current_data(sample_service, sample_user):
|
|
assert Template.query.count() == 0
|
|
assert TemplateHistory.query.count() == 0
|
|
data = {
|
|
'name': 'Sample Template',
|
|
'template_type': "email",
|
|
'subject': "subject",
|
|
'content': "Template content",
|
|
'service': sample_service,
|
|
'created_by': sample_user
|
|
}
|
|
template = Template(**data)
|
|
dao_create_template(template)
|
|
|
|
assert Template.query.count() == 1
|
|
|
|
template_from_db = Template.query.first()
|
|
template_history = TemplateHistory.query.first()
|
|
|
|
assert template_from_db.id == template_history.id
|
|
assert template_from_db.name == template_history.name
|
|
assert template_from_db.version == 1
|
|
assert template_from_db.version == template_history.version
|
|
assert sample_user.id == template_history.created_by_id
|
|
assert template_from_db.created_by.id == template_history.created_by_id
|
|
|
|
|
|
def test_update_template_creates_a_history_record_with_current_data(sample_service, sample_user):
|
|
assert Template.query.count() == 0
|
|
assert TemplateHistory.query.count() == 0
|
|
data = {
|
|
'name': 'Sample Template',
|
|
'template_type': "email",
|
|
'subject': "subject",
|
|
'content': "Template content",
|
|
'service': sample_service,
|
|
'created_by': sample_user
|
|
}
|
|
template = Template(**data)
|
|
dao_create_template(template)
|
|
|
|
created = dao_get_all_templates_for_service(sample_service.id)[0]
|
|
assert created.name == 'Sample Template'
|
|
assert Template.query.count() == 1
|
|
assert Template.query.first().version == 1
|
|
assert TemplateHistory.query.count() == 1
|
|
|
|
created.name = 'new name'
|
|
dao_update_template(created)
|
|
|
|
assert Template.query.count() == 1
|
|
assert TemplateHistory.query.count() == 2
|
|
|
|
template_from_db = Template.query.first()
|
|
|
|
assert template_from_db.version == 2
|
|
|
|
assert TemplateHistory.query.filter_by(name='Sample Template').one().version == 1
|
|
assert TemplateHistory.query.filter_by(name='new name').one().version == 2
|
|
|
|
|
|
def test_get_template_history_version(sample_user, sample_service, sample_template):
|
|
old_content = sample_template.content
|
|
sample_template.content = "New content"
|
|
dao_update_template(sample_template)
|
|
old_template = dao_get_template_by_id_and_service_id(
|
|
sample_template.id,
|
|
sample_service.id,
|
|
'1'
|
|
)
|
|
assert old_template.content == old_content
|
|
|
|
|
|
def test_can_get_template_then_redacted_returns_right_values(sample_template):
|
|
template = dao_get_template_by_id_and_service_id(template_id=sample_template.id,
|
|
service_id=sample_template.service_id)
|
|
assert not template.redact_personalisation
|
|
dao_redact_template(template=template, user_id=sample_template.created_by_id)
|
|
assert template.redact_personalisation
|
|
|
|
|
|
def test_get_template_versions(sample_template):
|
|
original_content = sample_template.content
|
|
sample_template.content = 'new version'
|
|
dao_update_template(sample_template)
|
|
versions = dao_get_template_versions(service_id=sample_template.service_id, template_id=sample_template.id)
|
|
assert len(versions) == 2
|
|
versions = sorted(versions, key=lambda x: x.version)
|
|
assert versions[0].content == original_content
|
|
assert versions[1].content == 'new version'
|
|
|
|
assert versions[0].created_at == versions[1].created_at
|
|
|
|
assert versions[0].updated_at is None
|
|
assert versions[1].updated_at is not None
|
|
|
|
from app.schemas import template_history_schema
|
|
v = template_history_schema.load(versions, many=True)
|
|
assert len(v) == 2
|
|
|
|
|
|
def test_get_template_versions_is_empty_for_hidden_templates(notify_db, notify_db_session, sample_service):
|
|
sample_template = create_sample_template(
|
|
notify_db,
|
|
notify_db_session,
|
|
template_name='Test Template',
|
|
hidden=True,
|
|
service=sample_service
|
|
)
|
|
versions = dao_get_template_versions(service_id=sample_template.service_id, template_id=sample_template.id)
|
|
assert len(versions) == 0
|
|
|
|
|
|
def test_get_multiple_template_details_returns_templates_for_list_of_ids(sample_service):
|
|
t1 = create_template(sample_service)
|
|
t2 = create_template(sample_service)
|
|
create_template(sample_service) # t3
|
|
|
|
res = dao_get_multiple_template_details([t1.id, t2.id])
|
|
|
|
assert {x.id for x in res} == {t1.id, t2.id}
|
|
# make sure correct properties are on each row
|
|
assert res[0].id
|
|
assert res[0].template_type
|
|
assert res[0].name
|
|
assert not res[0].is_precompiled_letter
|