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