def test_all_versions_of_template(notify_api, sample_template):
with notify_api.test_request_context():
with notify_api.test_client() as client:
old_content = sample_template.content
newer_content = "Newer content"
newest_content = "Newest content"
sample_template.content = newer_content
dao_update_template(sample_template)
sample_template.content = newest_content
dao_update_template(sample_template)
auth_header = create_authorization_header()
endpoint = url_for(
'template.get_template_versions',
service_id=sample_template.service.id,
template_id=sample_template.id
)
resp = client.get(
endpoint,
headers=[('Content-Type', 'application/json'), auth_header]
)
json_resp = json.loads(resp.get_data(as_text=True))
assert len(json_resp['data']) == 3
assert json_resp['data'][0]['content'] == newest_content
assert json_resp['data'][0]['updated_at']
assert json_resp['data'][1]['content'] == newer_content
assert json_resp['data'][1]['updated_at']
assert json_resp['data'][2]['content'] == old_content
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_notification_selects_correct_template_for_personalisation(client,
notify_db,
sample_template):
create_notification(sample_template)
original_content = sample_template.content
sample_template.content = '((name))'
dao_update_template(sample_template)
notify_db.session.commit()
create_notification(sample_template, personalisation={"name": "foo"})
auth_header = create_authorization_header(service_id=sample_template.service_id)
response = client.get(path='/notifications', headers=[auth_header])
assert response.status_code == 200
resp = json.loads(response.get_data(as_text=True))
notis = sorted(resp['notifications'], key=lambda x: x['template_version'])
assert len(notis) == 2
assert notis[0]['template_version'] == 1
assert notis[0]['body'] == original_content
assert notis[1]['template_version'] == 2
assert notis[1]['body'] == 'foo'
assert notis[0]['template_version'] == notis[0]['template']['version']
assert notis[1]['template_version'] == notis[1]['template']['version']
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_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_send_broadcast_message_sends_old_version_of_template(sample_service):
template = create_template(sample_service,
BROADCAST_TYPE,
content='first content')
broadcast_message = create_broadcast_message(
template, areas=['london'], status=BroadcastStatusType.BROADCASTING)
template.content = 'second content'
dao_update_template(template)
assert template.version == 2
with requests_mock.Mocker() as request_mock:
request_mock.post("http://test-cbc-proxy/broadcasts/stub-1",
json={'valid': 'true'},
status_code=200)
send_broadcast_message(broadcast_message_id=str(broadcast_message.id))
assert request_mock.call_count == 1
assert request_mock.request_history[0].method == 'POST'
assert request_mock.request_history[0].headers[
"Content-type"] == "application/json"
cbc_json = request_mock.request_history[0].json()
assert cbc_json['template']['id'] == str(template.id)
assert cbc_json['template']['version'] == 1
assert cbc_json['template']['content'] == 'first content'
def test_get_all_templates_for_service_is_alphabetised(sample_service):
create_template(
template_name="Sample Template 1",
template_type="sms",
content="Template content",
service=sample_service,
)
template_2 = create_template(
template_name="Sample Template 2",
template_type="sms",
content="Template content",
service=sample_service,
)
create_template(
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_send_email_should_use_template_version_from_job_not_latest(sample_email_template, mocker):
notification = _notification_json(sample_email_template, 'my_email@my_email.com')
version_on_notification = sample_email_template.version
# Change the template
from app.dao.templates_dao import dao_update_template, dao_get_template_by_id
sample_email_template.content = sample_email_template.content + " another version of the template"
mocker.patch('app.celery.provider_tasks.deliver_email.apply_async')
dao_update_template(sample_email_template)
t = dao_get_template_by_id(sample_email_template.id)
assert t.version > version_on_notification
now = datetime.utcnow()
send_email(
sample_email_template.service_id,
uuid.uuid4(),
encryption.encrypt(notification),
now.strftime(DATETIME_FORMAT)
)
persisted_notification = Notification.query.one()
assert persisted_notification.to == 'my_email@my_email.com'
assert persisted_notification.template_id == sample_email_template.id
assert persisted_notification.template_version == version_on_notification
assert persisted_notification.created_at == now
assert not persisted_notification.sent_at
assert persisted_notification.status == 'created'
assert not persisted_notification.sent_by
assert persisted_notification.notification_type == 'email'
provider_tasks.deliver_email.apply_async.assert_called_once_with([str(persisted_notification.id)],
queue='send-email')
def test_get_all_templates_for_service_is_alphabetised(sample_service):
create_template(
template_name='Sample Template 1',
template_type="sms",
content="Template content",
service=sample_service
)
template_2 = create_template(
template_name='Sample Template 2',
template_type="sms",
content="Template content",
service=sample_service
)
create_template(
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_all_versions_of_template(notify_api, sample_template):
with notify_api.test_request_context():
with notify_api.test_client() as client:
old_content = sample_template.content
newer_content = "Newer content"
newest_content = "Newest content"
sample_template.content = newer_content
dao_update_template(sample_template)
sample_template.content = newest_content
dao_update_template(sample_template)
auth_header = create_authorization_header()
endpoint = url_for(
"template.get_template_versions",
service_id=sample_template.service.id,
template_id=sample_template.id,
)
resp = client.get(endpoint,
headers=[("Content-Type", "application/json"),
auth_header])
json_resp = json.loads(resp.get_data(as_text=True))
assert len(json_resp["data"]) == 3
assert json_resp["data"][0]["content"] == newest_content
assert json_resp["data"][0]["updated_at"]
assert json_resp["data"][1]["content"] == newer_content
assert json_resp["data"][1]["updated_at"]
assert json_resp["data"][2]["content"] == old_content
def test_create_job_returns_400_if_archived_template(client, sample_template, mocker, fake_uuid):
mocker.patch('app.celery.tasks.process_job.apply_async')
sample_template.archived = True
dao_update_template(sample_template)
mocker.patch('app.job.rest.get_job_metadata_from_s3', return_value={
'template_id': str(sample_template.id),
})
data = {
'id': fake_uuid,
'valid': 'True',
}
path = '/service/{}/job'.format(sample_template.service.id)
auth_header = create_authorization_header()
headers = [('Content-Type', 'application/json'), auth_header]
response = client.post(
path,
data=json.dumps(data),
headers=headers)
resp_json = json.loads(response.get_data(as_text=True))
assert response.status_code == 400
app.celery.tasks.process_job.apply_async.assert_not_called()
assert resp_json['result'] == 'error'
assert 'Template has been deleted' in resp_json['message']['template']
def test_create_job_returns_400_if_archived_template(client, sample_template,
mocker, fake_uuid):
mocker.patch("app.celery.tasks.process_job.apply_async")
sample_template.archived = True
dao_update_template(sample_template)
mocker.patch(
"app.job.rest.get_job_metadata_from_s3",
return_value={
"template_id": str(sample_template.id),
},
)
data = {
"id": fake_uuid,
"valid": "True",
}
path = "/service/{}/job".format(sample_template.service.id)
auth_header = create_authorization_header()
headers = [("Content-Type", "application/json"), auth_header]
response = client.post(path, data=json.dumps(data), headers=headers)
resp_json = json.loads(response.get_data(as_text=True))
assert response.status_code == 400
app.celery.tasks.process_job.apply_async.assert_not_called()
assert resp_json["result"] == "error"
assert "Template has been deleted" in resp_json["message"]["template"]
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_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_get_all_templates_for_service_shows_newest_created_first(notify_db, notify_db_session, sample_service):
template_1 = 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
)
template_3 = 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 3'
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 1'
template_2.name = 'Sample Template 2 (updated)'
dao_update_template(template_2)
assert dao_get_all_templates_for_service(sample_service.id)[0].name == 'Sample Template 3'
assert dao_get_all_templates_for_service(sample_service.id)[1].name == 'Sample Template 2 (updated)'
def test_send_sms_should_use_template_version_from_notification_not_latest(
sample_template, mocker):
db_notification = create_notification(
template=sample_template,
to_field='+447234123123',
status='created',
reply_to_text=sample_template.service.get_default_sms_sender())
mocker.patch('app.mmg_client.send_sms')
version_on_notification = sample_template.version
# Change the template
from app.dao.templates_dao import dao_update_template, dao_get_template_by_id
sample_template.content = sample_template.content + " another version of the template"
dao_update_template(sample_template)
t = dao_get_template_by_id(sample_template.id)
assert t.version > version_on_notification
send_to_providers.send_sms_to_provider(db_notification)
mmg_client.send_sms.assert_called_once_with(
to=validate_and_format_phone_number("+447234123123"),
content="Sample service: This is a template:\nwith a newline",
reference=str(db_notification.id),
sender=current_app.config['FROM_NUMBER'])
persisted_notification = notifications_dao.get_notification_by_id(
db_notification.id)
assert persisted_notification.to == db_notification.to
assert persisted_notification.template_id == sample_template.id
assert persisted_notification.template_version == version_on_notification
assert persisted_notification.template_version != sample_template.version
assert persisted_notification.status == 'sending'
assert not persisted_notification.personalisation
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_check_template_is_active_fails(sample_template):
sample_template.archived = True
from app.dao.templates_dao import dao_update_template
dao_update_template(sample_template)
with pytest.raises(BadRequestError) as e:
check_template_is_active(sample_template)
assert e.value.status_code == 400
assert e.value.message == 'Template has been deleted'
assert e.value.fields == [{'template': 'Template has been deleted'}]
def test_check_template_is_active_fails(sample_template):
sample_template.archived = True
from app.dao.templates_dao import dao_update_template
dao_update_template(sample_template)
with pytest.raises(BadRequestError) as e:
check_template_is_active(sample_template)
assert e.value.status_code == 400
assert e.value.message == 'Template has been deleted'
assert e.value.fields == [{'template': 'Template has been deleted'}]
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_get_all_templates_ignores_archived_templates(sample_service):
normal_template = create_template(template_name='Normal Template',
service=sample_service,
archived=False)
archived_template = create_template(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 update_template(service_id, template_id):
fetched_template = dao_get_template_by_id_and_service_id(
template_id=template_id, service_id=service_id)
if not service_has_permission(
fetched_template.template_type,
[p.permission for p in fetched_template.service.permissions]):
message = "Updating {} templates is not allowed".format(
get_public_notify_type_text(fetched_template.template_type))
errors = {'template_type': [message]}
raise InvalidRequest(errors, 403)
data = request.get_json()
validate(data, post_update_template_schema)
# if redacting, don't update anything else
if data.get('redact_personalisation') is True:
return redact_template(fetched_template, data)
if "reply_to" in data:
check_reply_to(service_id, data.get("reply_to"),
fetched_template.template_type)
updated = dao_update_template_reply_to(template_id=template_id,
reply_to=data.get("reply_to"))
return jsonify(data=template_schema.dump(updated).data), 200
current_data = dict(template_schema.dump(fetched_template).data.items())
updated_template = dict(
template_schema.dump(fetched_template).data.items())
updated_template.update(data)
# Check if there is a change to make.
if _template_has_not_changed(current_data, updated_template):
return jsonify(data=updated_template), 200
over_limit = _content_count_greater_than_limit(
updated_template['content'], fetched_template.template_type)
if over_limit:
message = 'Content has a character count greater than the limit of {}'.format(
SMS_CHAR_COUNT_LIMIT)
errors = {'content': [message]}
raise InvalidRequest(errors, status_code=400)
update_dict = template_schema.load(updated_template).data
dao_update_template(update_dict)
return jsonify(data=template_schema.dump(update_dict).data), 200
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(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(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 deactivated_service_with_deleted_stuff(client, notify_db, notify_db_session, sample_service):
with freeze_time('2001-01-01'):
template = create_template(notify_db, notify_db_session, template_name='a')
api_key = create_api_key(notify_db, notify_db_session)
expire_api_key(sample_service.id, api_key.id)
template.archived = True
dao_update_template(template)
with freeze_time('2002-02-02'):
auth_header = create_authorization_header()
response = client.post('/service/{}/deactivate'.format(sample_service.id), headers=[auth_header])
assert response.status_code == 204
assert response.data == b''
return sample_service
def archived_service_with_deleted_stuff(client, sample_service):
with freeze_time('2001-01-01'):
template = create_template(sample_service, template_name='a')
api_key = create_api_key(sample_service)
expire_api_key(sample_service.id, api_key.id)
template.archived = True
dao_update_template(template)
with freeze_time('2002-02-02'):
auth_header = create_authorization_header()
response = client.post('/service/{}/archive'.format(sample_service.id), headers=[auth_header])
assert response.status_code == 204
assert response.data == b''
return sample_service
def test_template_postage_constraint_on_update(sample_service, sample_user):
data = {
"name": "Sample Template",
"template_type": "letter",
"content": "Template content",
"service": sample_service,
"created_by": sample_user,
"postage": "second",
}
template = Template(**data)
dao_create_template(template)
created = dao_get_all_templates_for_service(sample_service.id)[0]
assert created.name == "Sample Template"
created.postage = "third"
with pytest.raises(expected_exception=SQLAlchemyError):
dao_update_template(created)
def test_template_postage_constraint_on_update(sample_service, sample_user):
data = {
'name': 'Sample Template',
'template_type': "letter",
'content': "Template content",
'service': sample_service,
'created_by': sample_user,
'postage': 'second'
}
template = Template(**data)
dao_create_template(template)
created = dao_get_all_templates_for_service(sample_service.id)[0]
assert created.name == 'Sample Template'
created.postage = 'third'
with pytest.raises(expected_exception=SQLAlchemyError):
dao_update_template(created)
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_should_not_send_notification_for_archived_template(notify_api, sample_template):
with notify_api.test_request_context():
with notify_api.test_client() as client:
sample_template.archived = True
dao_update_template(sample_template)
json_data = json.dumps({
'to': '+16502532222',
'template': sample_template.id
})
auth_header = create_authorization_header(service_id=sample_template.service_id)
resp = client.post(
path='/notifications/sms',
data=json_data,
headers=[('Content-Type', 'application/json'), auth_header])
assert resp.status_code == 400
json_resp = json.loads(resp.get_data(as_text=True))
assert 'Template has been deleted' in json_resp['message']
def test_should_not_send_notification_for_archived_template(notify_api, sample_template):
with notify_api.test_request_context():
with notify_api.test_client() as client:
sample_template.archived = True
dao_update_template(sample_template)
json_data = json.dumps({
'to': '+447700900855',
'template': sample_template.id
})
auth_header = create_authorization_header(service_id=sample_template.service_id)
resp = client.post(
path='/notifications/sms',
data=json_data,
headers=[('Content-Type', 'application/json'), auth_header])
assert resp.status_code == 400
json_resp = json.loads(resp.get_data(as_text=True))
assert 'Template has been deleted' in json_resp['message']
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_previous_template_history_version(notify_api, sample_template):
old_content = sample_template.content
sample_template.content = "New content"
dao_update_template(sample_template)
with notify_api.test_request_context():
with notify_api.test_client() as client:
auth_header = create_authorization_header()
endpoint = url_for('template.get_template_version',
service_id=sample_template.service.id,
template_id=sample_template.id,
version=1)
resp = client.get(endpoint,
headers=[('Content-Type', 'application/json'),
auth_header])
assert resp.status_code == 200
json_resp = json.loads(resp.get_data(as_text=True))
assert json_resp['data']['id'] == str(sample_template.id)
assert json_resp['data']['version'] == 1
assert json_resp['data']['content'] == old_content
def test_update_template_reply_to_updates_history(client,
sample_letter_template):
auth_header = create_authorization_header()
letter_contact = create_letter_contact(sample_letter_template.service,
"Edinburgh, ED1 1AA")
sample_letter_template.reply_to = letter_contact.id
dao_update_template(sample_letter_template)
resp = client.get('/service/{}/template/{}/version/2'.format(
sample_letter_template.service_id, sample_letter_template.id),
headers=[auth_header])
assert resp.status_code == 200
hist_json_resp = json.loads(resp.get_data(as_text=True))
assert 'service_letter_contact_id' not in hist_json_resp['data']
assert hist_json_resp['data']['reply_to'] == str(letter_contact.id)
assert hist_json_resp['data'][
'reply_to_text'] == letter_contact.contact_block
def update_template(service_id, template_id):
fetched_template = dao_get_template_by_id_and_service_id(template_id=template_id, service_id=service_id)
current_data = dict(template_schema.dump(fetched_template).data.items())
updated_template = dict(template_schema.dump(fetched_template).data.items())
updated_template.update(request.get_json())
updated_template['content'] = _strip_html(updated_template['content'])
# Check if there is a change to make.
if _template_has_not_changed(current_data, updated_template):
return jsonify(data=updated_template), 200
update_dict = template_schema.load(updated_template).data
over_limit = _content_count_greater_than_limit(updated_template['content'], fetched_template.template_type)
if over_limit:
char_count_limit = current_app.config.get('SMS_CHAR_COUNT_LIMIT')
message = 'Content has a character count greater than the limit of {}'.format(char_count_limit)
errors = {'content': [message]}
raise InvalidRequest(errors, status_code=400)
dao_update_template(update_dict)
return jsonify(data=template_schema.dump(update_dict).data), 200
def test_should_return_all_template_versions_for_service_and_template_id(client, sample_template):
original_content = sample_template.content
from app.dao.templates_dao import dao_update_template
sample_template.content = original_content + '1'
dao_update_template(sample_template)
sample_template.content = original_content + '2'
dao_update_template(sample_template)
auth_header = create_authorization_header()
resp = client.get('/service/{}/template/{}/versions'.format(sample_template.service_id, sample_template.id),
headers=[('Content-Type', 'application/json'), auth_header])
assert resp.status_code == 200
resp_json = json.loads(resp.get_data(as_text=True))['data']
assert len(resp_json) == 3
for x in resp_json:
if x['version'] == 1:
assert x['content'] == original_content
elif x['version'] == 2:
assert x['content'] == original_content + '1'
else:
assert x['content'] == original_content + '2'
def test_should_return_all_template_versions_for_service_and_template_id(client, sample_template):
original_content = sample_template.content
from app.dao.templates_dao import dao_update_template
sample_template.content = original_content + '1'
dao_update_template(sample_template)
sample_template.content = original_content + '2'
dao_update_template(sample_template)
auth_header = create_authorization_header()
resp = client.get('/service/{}/template/{}/versions'.format(sample_template.service_id, sample_template.id),
headers=[('Content-Type', 'application/json'), auth_header])
assert resp.status_code == 200
resp_json = json.loads(resp.get_data(as_text=True))['data']
assert len(resp_json) == 3
for x in resp_json:
if x['version'] == 1:
assert x['content'] == original_content
elif x['version'] == 2:
assert x['content'] == original_content + '1'
else:
assert x['content'] == original_content + '2'
def test_previous_template_history_version(notify_api, sample_template):
old_content = sample_template.content
sample_template.content = "New content"
dao_update_template(sample_template)
with notify_api.test_request_context():
with notify_api.test_client() as client:
auth_header = create_authorization_header()
endpoint = url_for(
'template.get_template_version',
service_id=sample_template.service.id,
template_id=sample_template.id,
version=1)
resp = client.get(
endpoint,
headers=[('Content-Type', 'application/json'), auth_header]
)
assert resp.status_code == 200
json_resp = json.loads(resp.get_data(as_text=True))
assert json_resp['data']['id'] == str(sample_template.id)
assert json_resp['data']['version'] == 1
assert json_resp['data']['content'] == old_content
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_notification_selects_correct_template_for_personalisation(
client, notify_db, notify_db_session, sample_template):
create_sample_notification(
notify_db,
notify_db_session,
service=sample_template.service,
template=sample_template,
)
original_content = sample_template.content
sample_template.content = "((name))"
dao_update_template(sample_template)
notify_db.session.commit()
create_sample_notification(
notify_db,
notify_db_session,
service=sample_template.service,
template=sample_template,
personalisation={"name": "foo"},
)
auth_header = create_authorization_header(
service_id=sample_template.service_id)
response = client.get(path="/notifications", headers=[auth_header])
assert response.status_code == 200
resp = json.loads(response.get_data(as_text=True))
notis = sorted(resp["notifications"], key=lambda x: x["template_version"])
assert len(notis) == 2
assert notis[0]["template_version"] == 1
assert notis[0]["body"] == original_content
assert notis[1]["template_version"] == 2
assert notis[1]["body"] == "foo"
assert notis[0]["template_version"] == notis[0]["template"]["version"]
assert notis[1]["template_version"] == notis[1]["template"]["version"]
def create_template(
service,
template_type=SMS_TYPE,
template_name=None,
subject='Template subject',
content='Dear Sir/Madam, Hello. Yours Truly, The Government.',
reply_to=None,
hidden=False,
archived=False,
folder=None,
postage=None,
process_type='normal',
contact_block_id=None
):
data = {
'name': template_name or '{} Template Name'.format(template_type),
'template_type': template_type,
'content': content,
'service': service,
'created_by': service.created_by,
'reply_to': reply_to,
'hidden': hidden,
'folder': folder,
'process_type': process_type,
}
if template_type == LETTER_TYPE:
data["postage"] = postage or "second"
if contact_block_id:
data['service_letter_contact_id'] = contact_block_id
if template_type != SMS_TYPE:
data['subject'] = subject
template = Template(**data)
dao_create_template(template)
if archived:
template.archived = archived
dao_update_template(template)
return template
def test_create_job_returns_400_if_archived_template(notify_api,
sample_template, mocker):
with notify_api.test_request_context():
with notify_api.test_client() as client:
mocker.patch('app.celery.tasks.process_job.apply_async')
sample_template.archived = True
dao_update_template(sample_template)
data = {'template': str(sample_template.id)}
path = '/service/{}/job'.format(sample_template.service.id)
auth_header = create_authorization_header()
headers = [('Content-Type', 'application/json'), auth_header]
response = client.post(path,
data=json.dumps(data),
headers=headers)
resp_json = json.loads(response.get_data(as_text=True))
assert response.status_code == 400
app.celery.tasks.process_job.apply_async.assert_not_called()
assert resp_json['result'] == 'error'
assert 'Template has been deleted' in resp_json['message'][
'template']
def test_send_sms_should_use_template_version_from_notification_not_latest(
notify_db,
notify_db_session,
sample_template,
mocker):
db_notification = sample_notification(notify_db, notify_db_session,
template=sample_template, to_field='+447234123123',
status='created')
mocker.patch('app.mmg_client.send_sms')
mocker.patch('app.mmg_client.get_name', return_value="mmg")
version_on_notification = sample_template.version
# Change the template
from app.dao.templates_dao import dao_update_template, dao_get_template_by_id
sample_template.content = sample_template.content + " another version of the template"
dao_update_template(sample_template)
t = dao_get_template_by_id(sample_template.id)
assert t.version > version_on_notification
send_to_providers.send_sms_to_provider(
db_notification
)
mmg_client.send_sms.assert_called_once_with(
to=format_phone_number(validate_phone_number("+447234123123")),
content="Sample service: This is a template:\nwith a newline",
reference=str(db_notification.id),
sender=None
)
persisted_notification = notifications_dao.get_notification_by_id(db_notification.id)
assert persisted_notification.to == db_notification.to
assert persisted_notification.template_id == sample_template.id
assert persisted_notification.template_version == version_on_notification
assert persisted_notification.template_version != sample_template.version
assert persisted_notification.status == 'sending'
assert not persisted_notification.personalisation
def test_create_job_returns_400_if_archived_template(notify_api, sample_template, mocker):
with notify_api.test_request_context():
with notify_api.test_client() as client:
mocker.patch('app.celery.tasks.process_job.apply_async')
sample_template.archived = True
dao_update_template(sample_template)
data = {
'template': str(sample_template.id)
}
path = '/service/{}/job'.format(sample_template.service.id)
auth_header = create_authorization_header(service_id=sample_template.service.id)
headers = [('Content-Type', 'application/json'), auth_header]
response = client.post(
path,
data=json.dumps(data),
headers=headers)
resp_json = json.loads(response.get_data(as_text=True))
assert response.status_code == 400
app.celery.tasks.process_job.apply_async.assert_not_called()
assert resp_json['result'] == 'error'
assert 'Template has been deleted' in resp_json['message']['template']
def test_get_notification_selects_correct_template_for_personalisation(notify_api,
notify_db,
notify_db_session,
sample_template):
create_sample_notification(notify_db,
notify_db_session,
service=sample_template.service,
template=sample_template)
original_content = sample_template.content
sample_template.content = '((name))'
dao_update_template(sample_template)
notify_db.session.commit()
create_sample_notification(notify_db,
notify_db_session,
service=sample_template.service,
template=sample_template,
personalisation={"name": "foo"})
with notify_api.test_request_context(), notify_api.test_client() as client:
auth_header = create_authorization_header(service_id=sample_template.service_id)
response = client.get(path='/notifications', headers=[auth_header])
assert response.status_code == 200
resp = json.loads(response.get_data(as_text=True))
notis = sorted(resp['notifications'], key=lambda x: x['template_version'])
assert len(notis) == 2
assert notis[0]['template_version'] == 1
assert notis[0]['body'] == original_content
assert notis[1]['template_version'] == 2
assert notis[1]['body'] == 'foo'
assert notis[0]['template_version'] == notis[0]['template']['version']
assert notis[1]['template_version'] == notis[1]['template']['version']
def test_send_sms_should_use_template_version_from_notification_not_latest(sample_template, mocker):
db_notification = create_notification(
template=sample_template,
to_field="+16502532222",
status="created",
reply_to_text=sample_template.service.get_default_sms_sender(),
)
mocker.patch("app.aws_sns_client.send_sms", return_value="message_id_from_sns")
version_on_notification = sample_template.version
# Change the template
from app.dao.templates_dao import dao_get_template_by_id, dao_update_template
sample_template.content = sample_template.content + " another version of the template"
dao_update_template(sample_template)
t = dao_get_template_by_id(sample_template.id)
assert t.version > version_on_notification
send_to_providers.send_sms_to_provider(db_notification)
aws_sns_client.send_sms.assert_called_once_with(
to=validate_and_format_phone_number("+16502532222"),
content="Sample service: This is a template:\nwith a newline",
reference=str(db_notification.id),
sender=current_app.config["FROM_NUMBER"],
)
persisted_notification = notifications_dao.get_notification_by_id(db_notification.id)
assert persisted_notification.to == db_notification.to
assert persisted_notification.template_id == sample_template.id
assert persisted_notification.template_version == version_on_notification
assert persisted_notification.template_version != sample_template.version
assert persisted_notification.status == "sent"
assert persisted_notification.reference == "message_id_from_sns"
assert not persisted_notification.personalisation
