def test_add_letter_contact_when_multiple_defaults_exist_raises_exception(notify_db_session):
service = create_service()
create_letter_contact(service=service, contact_block='Edinburgh, ED1 1AA')
create_letter_contact(service=service, contact_block='Aberdeen, AB12 23X')
with pytest.raises(Exception):
add_letter_contact_for_service(service_id=service.id, contact_block='Swansea, SN1 3CC', is_default=False)
def test_dao_update_template_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,
'postage': 'second',
}
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_post_letter_notification_persists_notification_reply_to_text_for_template(
client, notify_db_session, mocker):
mocker.patch('app.celery.letters_pdf_tasks.create_letters_pdf.apply_async')
service = create_service(service_permissions=[LETTER_TYPE])
create_letter_contact(service=service,
contact_block='the default',
is_default=True)
template_letter_contact = create_letter_contact(
service=service, contact_block='not the default', is_default=False)
template = create_template(service=service,
template_type='letter',
reply_to=template_letter_contact.id)
data = {
"template_id": template.id,
"personalisation": {
'address_line_1': 'Foo',
'address_line_2': 'Bar',
'postcode': 'BA5 5AB'
}
}
letter_request(client,
data=data,
service_id=service.id,
key_type=KEY_TYPE_NORMAL)
notifications = Notification.query.all()
assert len(notifications) == 1
assert notifications[0].reply_to_text == 'not the default'
def test_get_template_reply_to(client, sample_service, template_default,
service_default):
auth_header = create_authorization_header()
if service_default:
create_letter_contact(service=sample_service,
contact_block=service_default,
is_default=True)
if template_default:
template_default_contact = create_letter_contact(
service=sample_service,
contact_block=template_default,
is_default=False)
reply_to_id = str(
template_default_contact.id) if template_default else None
template = create_template(service=sample_service,
template_type='letter',
reply_to=reply_to_id)
resp = client.get('/service/{}/template/{}'.format(template.service_id,
template.id),
headers=[auth_header])
assert resp.status_code == 200, resp.get_data(as_text=True)
json_resp = json.loads(resp.get_data(as_text=True))
assert 'service_letter_contact_id' not in json_resp['data']
assert json_resp['data']['reply_to'] == reply_to_id
assert json_resp['data']['reply_to_text'] == template_default
def test_dao_update_template_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,
"postage": "second",
}
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_archive_letter_contact(notify_db_session):
service = create_service()
create_letter_contact(service=service, contact_block='Aberdeen, AB12 23X')
letter_contact = create_letter_contact(service=service, contact_block='Edinburgh, ED1 1AA', is_default=False)
archive_letter_contact(service.id, letter_contact.id)
assert letter_contact.archived
assert letter_contact.updated_at is not None
def test_dao_get_letter_contacts_by_service_id(notify_db_session):
service = create_service()
default_letter_contact = create_letter_contact(service=service, contact_block='Edinburgh, ED1 1AA')
second_letter_contact = create_letter_contact(service=service, contact_block='Cardiff, CA1 2DB', is_default=False)
third_letter_contact = create_letter_contact(service=service, contact_block='London, E1 8QS', is_default=False)
results = dao_get_letter_contacts_by_service_id(service_id=service.id)
assert len(results) == 3
assert default_letter_contact == results[0]
assert third_letter_contact == results[1]
assert second_letter_contact == results[2]
def test_archive_letter_contact_does_not_archive_a_template_default_letter_contact(
notify_db_session):
service = create_service()
create_letter_contact(service=service, contact_block='Edinburgh, ED1 1AA')
template_default = create_letter_contact(
service=service, contact_block='Aberdeen, AB12 23X', is_default=False)
create_template(service=service,
template_type='letter',
reply_to=template_default.id)
with pytest.raises(ArchiveValidationError) as e:
archive_letter_contact(service.id, template_default.id)
assert 'You cannot delete the default letter contact block for a template' in str(
e.value)
def test_dao_get_letter_contacts_by_service_id_does_not_return_archived_contacts(notify_db_session):
service = create_service()
create_letter_contact(service=service, contact_block='Edinburgh, ED1 1AA')
create_letter_contact(service=service, contact_block='Cardiff, CA1 2DB', is_default=False)
archived_contact = create_letter_contact(
service=service,
contact_block='London, E1 8QS',
is_default=False,
archived=True
)
results = dao_get_letter_contacts_by_service_id(service_id=service.id)
assert len(results) == 2
assert archived_contact not in results
def test_add_letter_contact_for_service_creates_additional_letter_contact_for_service(notify_db_session):
service = create_service()
create_letter_contact(service=service, contact_block='Edinburgh, ED1 1AA')
add_letter_contact_for_service(service_id=service.id, contact_block='Swansea, SN1 3CC', is_default=False)
results = dao_get_letter_contacts_by_service_id(service_id=service.id)
assert len(results) == 2
assert results[0].contact_block == 'Edinburgh, ED1 1AA'
assert results[0].is_default
assert results[1].contact_block == 'Swansea, SN1 3CC'
assert not results[1].is_default
def test_add_another_letter_contact_as_default_overrides_existing(notify_db_session):
service = create_service()
create_letter_contact(service=service, contact_block='Edinburgh, ED1 1AA')
add_letter_contact_for_service(service_id=service.id, contact_block='Swansea, SN1 3CC', is_default=True)
results = dao_get_letter_contacts_by_service_id(service_id=service.id)
assert len(results) == 2
assert results[0].contact_block == 'Swansea, SN1 3CC'
assert results[0].is_default
assert results[1].contact_block == 'Edinburgh, ED1 1AA'
assert not results[1].is_default
def test_send_one_off_letter_notification_should_use_template_reply_to_text(
sample_letter_template, celery_mock):
letter_contact = create_letter_contact(sample_letter_template.service,
"Edinburgh, ED1 1AA",
is_default=False)
sample_letter_template.reply_to = str(letter_contact.id)
data = {
'to': '*****@*****.**',
'template_id': str(sample_letter_template.id),
'personalisation': {
'name': 'foo',
'address_line_1': 'First Last',
'address_line_2': '1 Example Street',
'address_line_3': 'SW1A 1AA',
},
'created_by': str(sample_letter_template.service.created_by_id)
}
notification_id = send_one_off_notification(
service_id=sample_letter_template.service.id, post_data=data)
notification = Notification.query.get(notification_id['id'])
celery_mock.assert_called_once_with(notification=notification,
research_mode=False,
queue=None)
assert notification.reply_to_text == "Edinburgh, ED1 1AA"
def test_create_a_template_with_foreign_service_reply_to(
admin_request, sample_user):
service = create_service(service_permissions=['letter'])
service2 = create_service(service_name='test service',
email_from='*****@*****.**',
service_permissions=['letter'])
letter_contact = create_letter_contact(service2, "Edinburgh, ED1 1AA")
data = {
'name': 'my template',
'subject': 'subject',
'template_type': 'letter',
'content': 'template <b>content</b>',
'service': str(service.id),
'created_by': str(sample_user.id),
'reply_to': str(letter_contact.id),
}
json_resp = admin_request.post('template.create_template',
service_id=service.id,
_data=data,
_expected_status=400)
assert json_resp[
'message'] == "letter_contact_id {} does not exist in database for service id {}".format(
str(letter_contact.id), str(service.id))
def test_archive_letter_contact_does_dissociates_template_defaults_before_archiving(notify_db_session):
service = create_service()
create_letter_contact(service=service, contact_block='Edinburgh, ED1 1AA')
template_default = create_letter_contact(service=service, contact_block='Aberdeen, AB12 23X', is_default=False)
associated_template_1 = create_template(service=service, template_type='letter', reply_to=template_default.id)
associated_template_2 = create_template(service=service, template_type='letter', reply_to=template_default.id)
assert associated_template_1.reply_to == template_default.id
assert associated_template_2.reply_to == template_default.id
assert template_default.archived is False
archive_letter_contact(service.id, template_default.id)
assert associated_template_1.reply_to is None
assert associated_template_2.reply_to is None
assert template_default.archived is True
def test_post_letter_notification_persists_notification_reply_to_text(
client, notify_db_session, mocker):
mocker.patch("app.celery.letters_pdf_tasks.create_letters_pdf.apply_async")
service = create_service(service_permissions=[LETTER_TYPE])
service_address = "12 Main Street, London"
letter_contact = create_letter_contact(service=service,
contact_block=service_address,
is_default=True)
template = create_template(service=service,
template_type="letter",
reply_to=letter_contact.id)
data = {
"template_id": template.id,
"personalisation": {
"address_line_1": "Foo",
"address_line_2": "Bar",
"postcode": "Baz",
},
}
letter_request(client,
data=data,
service_id=service.id,
key_type=KEY_TYPE_NORMAL)
notifications = Notification.query.all()
assert len(notifications) == 1
assert notifications[0].reply_to_text == service_address
def test_dao_get_letter_contact_by_id_raises_sqlalchemy_error_when_service_does_not_exist(
sample_service):
letter_contact = create_letter_contact(service=sample_service,
contact_block='Some address')
with pytest.raises(SQLAlchemyError):
dao_get_letter_contact_by_id(service_id=uuid.uuid4(),
letter_contact_id=letter_contact.id)
def test_archive_letter_contact_can_archive_a_service_default_letter_contact(
notify_db_session):
service = create_service()
letter_contact = create_letter_contact(service=service,
contact_block='Edinburgh, ED1 1AA')
archive_letter_contact(service.id, letter_contact.id)
assert letter_contact.archived is True
def test_check_service_letter_contact_id_where_service_id_is_not_found(sample_service, fake_uuid):
letter_contact = create_letter_contact(service=sample_service, contact_block='123456')
with pytest.raises(BadRequestError) as e:
check_service_letter_contact_id(fake_uuid, letter_contact.id, LETTER_TYPE)
assert e.value.status_code == 400
assert e.value.message == 'letter_contact_id {} does not exist in database for service id {}' \
.format(letter_contact.id, fake_uuid)
def test_update_template_with_foreign_service_reply_to(client,
sample_letter_template):
auth_header = create_authorization_header()
service2 = create_service(service_name='test service',
email_from='*****@*****.**',
service_permissions=['letter'])
letter_contact = create_letter_contact(service2, "Edinburgh, ED1 1AA")
data = {
'reply_to': str(letter_contact.id),
}
resp = client.post('/service/{}/template/{}'.format(
sample_letter_template.service_id, sample_letter_template.id),
data=json.dumps(data),
headers=[('Content-Type', 'application/json'),
auth_header])
assert resp.status_code == 400, resp.get_data(as_text=True)
json_resp = json.loads(resp.get_data(as_text=True))
assert json_resp[
'message'] == "letter_contact_id {} does not exist in database for service id {}".format(
str(letter_contact.id), str(sample_letter_template.service_id))
def test_get_letter_template_by_id_returns_placeholders(
client,
sample_service,
version,
):
contact_block = create_letter_contact(
service=sample_service,
contact_block='((contact block))',
)
template = create_template(
sample_service,
template_type=LETTER_TYPE,
subject="((letterSubject))",
content="((letter_content))",
reply_to=contact_block.id,
)
auth_header = create_authorization_header(service_id=sample_service.id)
version_path = '/version/{}'.format(version) if version else ''
response = client.get(path='/v2/template/{}{}'.format(template.id, version_path),
headers=[('Content-Type', 'application/json'), auth_header])
json_response = json.loads(response.get_data(as_text=True))
assert json_response['personalisation'] == {
"letterSubject": {
"required": True,
},
"letter_content": {
"required": True,
},
"contact block": {
"required": True,
},
}
def test_dao_get_letter_contact_by_id_raises_sqlalchemy_error_when_letter_contact_is_archived(sample_service):
archived_contact = create_letter_contact(
service=sample_service,
contact_block='Aberdeen, AB12 23X',
archived=True)
with pytest.raises(SQLAlchemyError):
dao_get_letter_contact_by_id(service_id=sample_service.id, letter_contact_id=archived_contact.id)
def test_check_service_letter_contact_id_where_letter_contact_id_is_found(
sample_service, ):
letter_contact = create_letter_contact(service=sample_service,
contact_block="123456")
assert check_service_letter_contact_id(sample_service.id,
letter_contact.id,
LETTER_TYPE) == "123456"
def test_create_a_template_with_reply_to(admin_request, sample_user):
service = create_service(service_permissions=['letter'])
letter_contact = create_letter_contact(service, "Edinburgh, ED1 1AA")
data = {
'name': 'my template',
'subject': 'subject',
'template_type': 'letter',
'content': 'template <b>content</b>',
'service': str(service.id),
'created_by': str(sample_user.id),
'reply_to': str(letter_contact.id),
}
json_resp = admin_request.post('template.create_template',
service_id=service.id,
_data=data,
_expected_status=201)
assert json_resp['data']['template_type'] == 'letter'
assert json_resp['data']['reply_to'] == str(letter_contact.id)
assert json_resp['data']['reply_to_text'] == letter_contact.contact_block
template = Template.query.get(json_resp['data']['id'])
from app.schemas import template_schema
assert sorted(json_resp['data']) == sorted(
template_schema.dump(template).data)
th = TemplateHistory.query.filter_by(id=template.id, version=1).one()
assert th.service_letter_contact_id == letter_contact.id
def test_post_notification_returns_400_for_missing_letter_contact_block_personalisation(
client,
sample_service,
):
letter_contact_block = create_letter_contact(
service=sample_service, contact_block='((contact block))', is_default=True
)
template = create_template(
service=sample_service,
template_type='letter',
reply_to=letter_contact_block.id,
)
data = {
'template_id': str(template.id),
'personalisation': {
'address_line_1': 'Line 1',
'address_line_2': 'Line 2',
'postcode': 'SW1A 1AA',
},
}
error_json = letter_request(
client,
data,
service_id=sample_service.id,
_expected_status=400,
)
assert error_json['status_code'] == 400
assert error_json['errors'] == [{
'error': 'BadRequestError',
'message': 'Missing personalisation: contact block'
}]
def test_update_letter_contact_unset_default_for_only_letter_contact_is_fine(notify_db_session):
service = create_service()
only_letter_contact = create_letter_contact(service=service, contact_block='Aberdeen, AB12 23X')
update_letter_contact(
service_id=service.id,
letter_contact_id=only_letter_contact.id,
contact_block='Warwick, W14 TSR',
is_default=False
)
assert only_letter_contact.is_default is False
def test_archive_letter_contact_does_not_archive_a_service_default_letter_contact(
notify_db_session):
service = create_service()
letter_contact = create_letter_contact(service=service,
contact_block='Edinburgh, ED1 1AA')
with pytest.raises(ArchiveValidationError) as e:
archive_letter_contact(service.id, letter_contact.id)
assert 'You cannot delete a default letter contact block' in str(e.value)
def test_get_template_by_id_returns_200(client, sample_service, tmp_type,
expected_name, expected_subject,
version, postage):
letter_contact_block_id = None
if tmp_type == 'letter':
letter_contact_block = create_letter_contact(
sample_service, "Buckingham Palace, London, SW1A 1AA")
letter_contact_block_id = letter_contact_block.id
template = create_template(sample_service,
template_type=tmp_type,
contact_block_id=(letter_contact_block_id))
auth_header = create_authorization_header(service_id=sample_service.id)
version_path = '/version/{}'.format(version) if version else ''
response = client.get(path='/v2/template/{}{}'.format(
template.id, version_path),
headers=[('Content-Type', 'application/json'),
auth_header])
assert response.status_code == 200
assert response.headers['Content-type'] == 'application/json'
json_response = json.loads(response.get_data(as_text=True))
expected_response = {
'id':
'{}'.format(template.id),
'type':
'{}'.format(template.template_type),
'created_at':
template.created_at.strftime(DATETIME_FORMAT),
'updated_at':
None,
'version':
template.version,
'created_by':
template.created_by.email_address,
'body':
template.content,
"subject":
expected_subject,
'name':
expected_name,
'personalisation': {},
'postage':
postage,
'letter_contact_block':
letter_contact_block.contact_block
if letter_contact_block_id else None,
}
assert json_response == expected_response
def test_update_letter_contact_unset_default_for_only_letter_contact_raises_exception(notify_db_session):
service = create_service()
only_letter_contact = create_letter_contact(service=service, contact_block='Aberdeen, AB12 23X')
with pytest.raises(expected_exception=InvalidRequest):
update_letter_contact(
service_id=service.id,
letter_contact_id=only_letter_contact.id,
contact_block='Warwick, W14 TSR',
is_default=False
)
def test_update_letter_contact_as_default_overides_existing_default(notify_db_session):
service = create_service()
create_letter_contact(service=service, contact_block='Aberdeen, AB12 23X')
second_letter_contact = create_letter_contact(service=service, contact_block='Swansea, SN1 3CC', is_default=False)
update_letter_contact(
service_id=service.id,
letter_contact_id=second_letter_contact.id,
contact_block='Warwick, W14 TSR',
is_default=True
)
results = dao_get_letter_contacts_by_service_id(service_id=service.id)
assert len(results) == 2
assert results[0].contact_block == 'Warwick, W14 TSR'
assert results[0].is_default
assert results[1].contact_block == 'Aberdeen, AB12 23X'
assert not results[1].is_default
def test_archive_letter_contact_does_not_archive_a_letter_contact_for_a_different_service(
notify_db_session,
sample_service,
):
service = create_service(service_name="First service")
letter_contact = create_letter_contact(service=sample_service,
contact_block='Edinburgh, ED1 1AA',
is_default=False)
with pytest.raises(SQLAlchemyError):
archive_letter_contact(service.id, letter_contact.id)
assert not letter_contact.archived
