From c34b24014a708c34f2f4f4ffec85e7f32aae08e2 Mon Sep 17 00:00:00 2001 From: stvnrlly Date: Fri, 17 Feb 2023 22:56:54 -0500 Subject: [PATCH] remove service letter contact model --- app/dao/services_dao.py | 2 - app/dao/templates_dao.py | 30 ------ app/models.py | 53 +--------- app/schemas.py | 7 +- app/service/service_data_retention_schema.py | 2 +- app/template/rest.py | 6 -- .../versions/0388_no_serv_letter_contact.py | 45 +++++++++ tests/app/celery/test_tasks.py | 46 --------- tests/app/conftest.py | 7 -- tests/app/dao/test_templates_dao.py | 99 +------------------ tests/app/db.py | 21 ---- .../test_send_one_off_notification.py | 51 ---------- .../test_service_data_retention_rest.py | 7 +- tests/app/template/test_rest.py | 87 +--------------- tests/app/template/test_rest_history.py | 20 ---- tests/app/v2/template/test_get_template.py | 43 +------- 16 files changed, 57 insertions(+), 469 deletions(-) create mode 100644 migrations/versions/0388_no_serv_letter_contact.py diff --git a/app/dao/services_dao.py b/app/dao/services_dao.py index 7ef1bcbbc..0c7113101 100644 --- a/app/dao/services_dao.py +++ b/app/dao/services_dao.py @@ -32,7 +32,6 @@ from app.models import ( Service, ServiceContactList, ServiceEmailReplyTo, - ServiceLetterContact, ServicePermission, ServiceSmsSender, Template, @@ -369,7 +368,6 @@ def delete_service_and_all_associated_db_objects(service): _delete_commit(ServiceSmsSender.query.filter_by(service=service)) _delete_commit(ServiceEmailReplyTo.query.filter_by(service=service)) - _delete_commit(ServiceLetterContact.query.filter_by(service=service)) _delete_commit(ServiceContactList.query.filter_by(service=service)) _delete_commit(InvitedUser.query.filter_by(service=service)) _delete_commit(Permission.query.filter_by(service=service)) diff --git a/app/dao/templates_dao.py b/app/dao/templates_dao.py index f6d5da06a..225718f93 100644 --- a/app/dao/templates_dao.py +++ b/app/dao/templates_dao.py @@ -38,36 +38,6 @@ def dao_update_template(template): db.session.add(template) -@autocommit -def dao_update_template_reply_to(template_id, reply_to): - Template.query.filter_by(id=template_id).update( - {"service_letter_contact_id": reply_to, - "updated_at": datetime.utcnow(), - "version": Template.version + 1, - } - ) - template = Template.query.filter_by(id=template_id).one() - - history = TemplateHistory(** - { - "id": template.id, - "name": template.name, - "template_type": template.template_type, - "created_at": template.created_at, - "updated_at": template.updated_at, - "content": template.content, - "service_id": template.service_id, - "subject": template.subject, - "created_by_id": template.created_by_id, - "version": template.version, - "archived": template.archived, - "process_type": template.process_type, - "service_letter_contact_id": template.service_letter_contact_id, - }) - db.session.add(history) - return template - - @autocommit def dao_redact_template(template, user_id): template.template_redacted.redact_personalisation = True diff --git a/app/models.py b/app/models.py index 360c8b5b9..a10b146bd 100644 --- a/app/models.py +++ b/app/models.py @@ -512,10 +512,6 @@ class Service(db.Model, Versioned): default_reply_to = [x for x in self.reply_to_email_addresses if x.is_default] return default_reply_to[0].email_address if default_reply_to else None - def get_default_letter_contact(self): - default_letter_contact = [x for x in self.letter_contacts if x.is_default] - return default_letter_contact[0].contact_block if default_letter_contact else None - def has_permission(self, permission): return permission in [p.permission for p in self.permissions] @@ -916,34 +912,20 @@ class TemplateBase(db.Model): redact_personalisation = association_proxy('template_redacted', 'redact_personalisation') - @declared_attr - def service_letter_contact_id(cls): - return db.Column(UUID(as_uuid=True), db.ForeignKey('service_letter_contacts.id'), nullable=True) - - @declared_attr - def service_letter_contact(cls): - return db.relationship('ServiceLetterContact', viewonly=True) - + # TODO: possibly unnecessary after removing letters @property def reply_to(self): - if self.template_type == LETTER_TYPE: - return self.service_letter_contact_id - else: - return None + return None @reply_to.setter def reply_to(self, value): - if self.template_type == LETTER_TYPE: - self.service_letter_contact_id = value - elif value is None: + if value is None: pass else: raise ValueError('Unable to set sender for {} template'.format(self.template_type)) def get_reply_to_text(self): - if self.template_type == LETTER_TYPE: - return self.service_letter_contact.contact_block if self.service_letter_contact else None - elif self.template_type == EMAIL_TYPE: + if self.template_type == EMAIL_TYPE: return self.service.get_default_reply_to_email_address() elif self.template_type == SMS_TYPE: return try_validate_and_format_phone_number(self.service.get_default_sms_sender()) @@ -983,7 +965,6 @@ class TemplateBase(db.Model): } for key in self._as_utils_template().placeholders }, - "letter_contact_block": self.service_letter_contact.contact_block if self.service_letter_contact else None, } return serialized @@ -1924,32 +1905,6 @@ class ServiceEmailReplyTo(db.Model): } -class ServiceLetterContact(db.Model): - __tablename__ = "service_letter_contacts" - - id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4) - - service_id = db.Column(UUID(as_uuid=True), db.ForeignKey('services.id'), unique=False, index=True, nullable=False) - service = db.relationship(Service, backref=db.backref("letter_contacts")) - - contact_block = db.Column(db.Text, nullable=False, index=False, unique=False) - is_default = db.Column(db.Boolean, nullable=False, default=True) - archived = db.Column(db.Boolean, nullable=False, default=False) - created_at = db.Column(db.DateTime, nullable=False, default=datetime.datetime.utcnow) - updated_at = db.Column(db.DateTime, nullable=True, onupdate=datetime.datetime.utcnow) - - def serialize(self): - return { - 'id': str(self.id), - 'service_id': str(self.service_id), - 'contact_block': self.contact_block, - 'is_default': self.is_default, - 'archived': self.archived, - 'created_at': self.created_at.strftime(DATETIME_FORMAT), - 'updated_at': get_dt_string_or_none(self.updated_at), - } - - class AuthType(db.Model): __tablename__ = 'auth_type' diff --git a/app/schemas.py b/app/schemas.py index 5d0cd2e0e..ed80daf69 100644 --- a/app/schemas.py +++ b/app/schemas.py @@ -249,9 +249,6 @@ class ServiceSchema(BaseSchema, UUIDsAsStringsMixin): return in_data - def get_letter_contact(self, service): - return service.get_default_letter_contact() - class Meta(BaseSchema.Meta): model = models.Service exclude = ( @@ -267,7 +264,6 @@ class ServiceSchema(BaseSchema, UUIDsAsStringsMixin): 'inbound_number', 'inbound_sms', 'jobs', - 'letter_contacts', 'reply_to_email_addresses', 'returned_letters', 'service_sms_senders', @@ -360,7 +356,7 @@ class BaseTemplateSchema(BaseSchema): class Meta(BaseSchema.Meta): model = models.Template - exclude = ("service_id", "jobs", "service_letter_contact_id") + exclude = ("service_id", "jobs") class TemplateSchema(BaseTemplateSchema, UUIDsAsStringsMixin): @@ -405,7 +401,6 @@ class TemplateSchemaNoDetail(TemplateSchema): 'reply_to', 'reply_to_text', 'service', - 'service_letter_contact', 'subject', 'template_redacted', 'updated_at', diff --git a/app/service/service_data_retention_schema.py b/app/service/service_data_retention_schema.py index 24944fedf..ea7efbe00 100644 --- a/app/service/service_data_retention_schema.py +++ b/app/service/service_data_retention_schema.py @@ -5,7 +5,7 @@ add_service_data_retention_request = { "type": "object", "properties": { "days_of_retention": {"type": "integer"}, - "notification_type": {"enum": ["sms", "letter", "email"]}, + "notification_type": {"enum": ["sms", "email"]}, }, "required": ["days_of_retention", "notification_type"] } diff --git a/app/template/rest.py b/app/template/rest.py index 47e6e38c0..204ce8c73 100644 --- a/app/template/rest.py +++ b/app/template/rest.py @@ -14,7 +14,6 @@ from app.dao.templates_dao import ( dao_get_template_versions, dao_redact_template, dao_update_template, - dao_update_template_reply_to, ) from app.errors import InvalidRequest, register_errors from app.models import SMS_TYPE, Template @@ -111,11 +110,6 @@ def update_template(service_id, template_id): 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)), 200 - current_data = dict(template_schema.dump(fetched_template).items()) updated_template = dict(template_schema.dump(fetched_template).items()) updated_template.update(data) diff --git a/migrations/versions/0388_no_serv_letter_contact.py b/migrations/versions/0388_no_serv_letter_contact.py new file mode 100644 index 000000000..bbbafa6c5 --- /dev/null +++ b/migrations/versions/0388_no_serv_letter_contact.py @@ -0,0 +1,45 @@ +""" + +Revision ID: 0388_no_serv_letter_contact.py +Revises: 0387_remove_letter_perms_.py +Create Date: 2023-02-17 14:42:52.679425 + +""" +from alembic import op +import sqlalchemy as sa +from sqlalchemy.dialects import postgresql + +revision = '0388_no_serv_letter_contact.py' +down_revision = '0387_remove_letter_perms_.py' + + +def upgrade(): + # ### commands auto generated by Alembic - please adjust! ### + op.drop_index('ix_service_letter_contacts_service_id', table_name='service_letter_contacts') + op.drop_constraint('templates_service_letter_contact_id_fkey', 'templates', type_='foreignkey') + op.drop_column('templates', 'service_letter_contact_id') + op.drop_constraint('templates_history_service_letter_contact_id_fkey', 'templates_history', type_='foreignkey') + op.drop_column('templates_history', 'service_letter_contact_id') + op.drop_table('service_letter_contacts') + # ### end Alembic commands ### + + +def downgrade(): + # ### commands auto generated by Alembic - please adjust! ### + op.add_column('templates_history', sa.Column('service_letter_contact_id', postgresql.UUID(), autoincrement=False, nullable=True)) + op.create_foreign_key('templates_history_service_letter_contact_id_fkey', 'templates_history', 'service_letter_contacts', ['service_letter_contact_id'], ['id']) + op.add_column('templates', sa.Column('service_letter_contact_id', postgresql.UUID(), autoincrement=False, nullable=True)) + op.create_foreign_key('templates_service_letter_contact_id_fkey', 'templates', 'service_letter_contacts', ['service_letter_contact_id'], ['id']) + op.create_table('service_letter_contacts', + sa.Column('id', postgresql.UUID(), autoincrement=False, nullable=False), + sa.Column('service_id', postgresql.UUID(), autoincrement=False, nullable=False), + sa.Column('contact_block', sa.TEXT(), autoincrement=False, nullable=False), + sa.Column('is_default', sa.BOOLEAN(), autoincrement=False, nullable=False), + sa.Column('created_at', postgresql.TIMESTAMP(), autoincrement=False, nullable=False), + sa.Column('updated_at', postgresql.TIMESTAMP(), autoincrement=False, nullable=True), + sa.Column('archived', sa.BOOLEAN(), server_default=sa.text('false'), autoincrement=False, nullable=False), + sa.ForeignKeyConstraint(['service_id'], ['services.id'], name='service_letter_contacts_service_id_fkey'), + sa.PrimaryKeyConstraint('id', name='service_letter_contacts_pkey') + ) + op.create_index('ix_service_letter_contacts_service_id', 'service_letter_contacts', ['service_id'], unique=False) + # ### end Alembic commands ### diff --git a/tests/app/celery/test_tasks.py b/tests/app/celery/test_tasks.py index 0d98ff54e..65b9c2335 100644 --- a/tests/app/celery/test_tasks.py +++ b/tests/app/celery/test_tasks.py @@ -9,7 +9,6 @@ from celery.exceptions import Retry from freezegun import freeze_time from notifications_utils.recipients import Row from notifications_utils.template import ( - LetterPrintTemplate, PlainTextEmailTemplate, SMSMessageTemplate, ) @@ -39,7 +38,6 @@ from app.models import ( JOB_STATUS_FINISHED, JOB_STATUS_IN_PROGRESS, KEY_TYPE_NORMAL, - LETTER_TYPE, NOTIFICATION_CREATED, SMS_TYPE, Job, @@ -53,7 +51,6 @@ from tests.app.db import ( create_api_key, create_inbound_sms, create_job, - create_letter_contact, create_notification, create_reply_to_email, create_service, @@ -976,49 +973,6 @@ def test_get_sms_template_instance(mocker, sample_template, sample_job): ] -@pytest.mark.skip(reason="Needs updating for TTS: Remove mail") -def test_get_letter_template_instance(mocker, sample_job): - mocker.patch( - 'app.celery.tasks.s3.get_job_and_metadata_from_s3', - return_value=('', {}), - ) - sample_contact_block = create_letter_contact( - service=sample_job.service, - contact_block='((reference number))' - ) - sample_template = create_template( - service=sample_job.service, - template_type=LETTER_TYPE, - reply_to=sample_contact_block.id, - ) - sample_job.template_id = sample_template.id - - ( - recipient_csv, - template, - _sender_id, - ) = get_recipient_csv_and_template_and_sender_id(sample_job) - - assert isinstance(template, LetterPrintTemplate) - assert template.contact_block == ( - '((reference number))' - ) - assert template.placeholders == { - 'reference number' - } - assert recipient_csv.placeholders == [ - 'reference number', - 'address line 1', - 'address line 2', - 'address line 3', - 'address line 4', - 'address line 5', - 'address line 6', - 'postcode', - 'address line 7', - ] - - def test_send_inbound_sms_to_service_post_https_request_to_service(notify_api, sample_service): inbound_api = create_service_inbound_api(service=sample_service, url="https://some.service.gov.uk/", bearer_token="something_unique") diff --git a/tests/app/conftest.py b/tests/app/conftest.py index afd1490dc..26438a12f 100644 --- a/tests/app/conftest.py +++ b/tests/app/conftest.py @@ -49,7 +49,6 @@ from tests.app.db import ( create_inbound_number, create_invited_org_user, create_job, - create_letter_contact, create_notification, create_service, create_template, @@ -238,12 +237,6 @@ def _sample_service_full_permissions(notify_db_session): return service -@pytest.fixture(scope='function', name='sample_service_custom_letter_contact_block') -def _sample_service_custom_letter_contact_block(sample_service): - create_letter_contact(sample_service, contact_block='((contact block))') - return sample_service - - @pytest.fixture(scope='function') def sample_template(sample_user): service = create_service(service_permissions=[EMAIL_TYPE, SMS_TYPE], check_if_service_exists=True) diff --git a/tests/app/dao/test_templates_dao.py b/tests/app/dao/test_templates_dao.py index 4b8265f3e..04dc311c5 100644 --- a/tests/app/dao/test_templates_dao.py +++ b/tests/app/dao/test_templates_dao.py @@ -11,10 +11,9 @@ from app.dao.templates_dao import ( dao_get_template_versions, dao_redact_template, dao_update_template, - dao_update_template_reply_to, ) from app.models import Template, TemplateHistory, TemplateRedacted -from tests.app.db import create_letter_contact, create_template +from tests.app.db import create_template @pytest.mark.parametrize('template_type, subject', [ @@ -52,23 +51,6 @@ def test_create_template_creates_redact_entry(sample_service): assert redacted.updated_by_id == sample_service.created_by_id -def test_create_template_with_reply_to(sample_service, sample_user): - letter_contact = create_letter_contact(sample_service, 'Edinburgh, ED1 1AA') - - data = { - 'name': 'Sample Template', - 'template_type': "letter", - 'content': "Template content", - 'service': sample_service, - 'created_by': sample_user, - 'reply_to': letter_contact.id, - } - template = Template(**data) - dao_create_template(template) - - assert dao_get_all_templates_for_service(sample_service.id)[0].reply_to == letter_contact.id - - def test_update_template(sample_service, sample_user): data = { 'name': 'Sample Template', @@ -87,85 +69,6 @@ def test_update_template(sample_service, sample_user): assert dao_get_all_templates_for_service(sample_service.id)[0].name == 'new name' -def test_dao_update_template_reply_to_none_to_some(sample_service, sample_user): - letter_contact = create_letter_contact(sample_service, 'Edinburgh, ED1 1AA') - - data = { - 'name': 'Sample Template', - 'template_type': "letter", - 'content': "Template content", - 'service': sample_service, - 'created_by': sample_user, - } - template = Template(**data) - dao_create_template(template) - created = Template.query.get(template.id) - assert created.reply_to is None - assert created.service_letter_contact_id is None - - dao_update_template_reply_to(template_id=template.id, - reply_to=letter_contact.id) - - updated = Template.query.get(template.id) - assert updated.reply_to == letter_contact.id - assert updated.version == 2 - assert updated.updated_at - - template_history = TemplateHistory.query.filter_by(id=created.id, version=2).one() - assert template_history.service_letter_contact_id == letter_contact.id - assert template_history.updated_at == updated.updated_at - - -def test_dao_update_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, - } - template = Template(**data) - dao_create_template(template) - created = Template.query.get(template.id) - dao_update_template_reply_to(template_id=created.id, reply_to=letter_contact_2.id) - updated = Template.query.get(template.id) - assert updated.reply_to == letter_contact_2.id - assert updated.version == 2 - assert updated.updated_at - - updated_history = TemplateHistory.query.filter_by(id=created.id, version=2).one() - assert updated_history.service_letter_contact_id == letter_contact_2.id - assert updated_history.updated_at == updated_history.updated_at - - -def test_dao_update_template_reply_to_some_to_none(sample_service, sample_user): - letter_contact = create_letter_contact(sample_service, 'Edinburgh, ED1 1AA') - data = { - 'name': 'Sample Template', - 'template_type': "letter", - 'content': "Template content", - 'service': sample_service, - 'created_by': sample_user, - 'service_letter_contact_id': letter_contact.id, - } - template = Template(**data) - dao_create_template(template) - created = Template.query.get(template.id) - dao_update_template_reply_to(template_id=created.id, reply_to=None) - updated = Template.query.get(template.id) - assert updated.reply_to is None - assert updated.version == 2 - assert updated.updated_at - - history = TemplateHistory.query.filter_by(id=created.id, version=2).one() - assert history.service_letter_contact_id is None - assert history.updated_at == updated.updated_at - - def test_redact_template(sample_template): redacted = TemplateRedacted.query.one() assert redacted.template_id == sample_template.id diff --git a/tests/app/db.py b/tests/app/db.py index 391e7be1a..d2ec3ae51 100644 --- a/tests/app/db.py +++ b/tests/app/db.py @@ -57,7 +57,6 @@ from app.models import ( ServiceEmailReplyTo, ServiceGuestList, ServiceInboundApi, - ServiceLetterContact, ServicePermission, ServiceSmsSender, Template, @@ -578,26 +577,6 @@ def create_service_sms_sender( return service_sms_sender -def create_letter_contact( - service, - contact_block, - is_default=True, - archived=False -): - data = { - 'service': service, - 'contact_block': contact_block, - 'is_default': is_default, - 'archived': archived, - } - letter_content = ServiceLetterContact(**data) - - db.session.add(letter_content) - db.session.commit() - - return letter_content - - def create_annual_billing( service_id, free_sms_fragment_limit, financial_year_start ): diff --git a/tests/app/service/send_notification/test_send_one_off_notification.py b/tests/app/service/send_notification/test_send_one_off_notification.py index 8830a1a8a..fcc458b02 100644 --- a/tests/app/service/send_notification/test_send_one_off_notification.py +++ b/tests/app/service/send_notification/test_send_one_off_notification.py @@ -21,7 +21,6 @@ from app.models import ( from app.service.send_notification import send_one_off_notification from app.v2.errors import BadRequestError, TooManyRequestsError from tests.app.db import ( - create_letter_contact, create_reply_to_email, create_service, create_service_sms_sender, @@ -307,56 +306,6 @@ def test_send_one_off_notification_should_add_email_reply_to_text_for_notificati assert notification.reply_to_text == reply_to_email.email_address -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': 'user@example.com', - '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" - - -@pytest.mark.skip(reason="Needs updating for TTS: Remove letters") -def test_send_one_off_letter_should_not_make_pdf_in_research_mode(sample_letter_template): - - sample_letter_template.service.research_mode = True - - data = { - 'to': 'A. Name', - '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 = send_one_off_notification(service_id=sample_letter_template.service.id, post_data=data) - notification = Notification.query.get(notification['id']) - - assert notification.status == "delivered" - - def test_send_one_off_sms_notification_should_use_sms_sender_reply_to_text(sample_service, celery_mock): template = create_template(service=sample_service, template_type=SMS_TYPE) sms_sender = create_service_sms_sender( diff --git a/tests/app/service/test_service_data_retention_rest.py b/tests/app/service/test_service_data_retention_rest.py index 97fbdfd91..ab122aae9 100644 --- a/tests/app/service/test_service_data_retention_rest.py +++ b/tests/app/service/test_service_data_retention_rest.py @@ -10,8 +10,6 @@ def test_get_service_data_retention(client, sample_service): sms_data_retention = create_service_data_retention(service=sample_service) email_data_retention = create_service_data_retention(service=sample_service, notification_type='email', days_of_retention=10) - letter_data_retention = create_service_data_retention(service=sample_service, notification_type='letter', - days_of_retention=30) response = client.get( '/service/{}/data-retention'.format(str(sample_service.id)), @@ -20,10 +18,9 @@ def test_get_service_data_retention(client, sample_service): assert response.status_code == 200 json_response = json.loads(response.get_data(as_text=True)) - assert len(json_response) == 3 + assert len(json_response) == 2 assert json_response[0] == email_data_retention.serialize() assert json_response[1] == sms_data_retention.serialize() - assert json_response[2] == letter_data_retention.serialize() def test_get_service_data_retention_returns_empty_list(client, sample_service): @@ -99,7 +96,7 @@ def test_create_service_data_retention_returns_400_when_notification_type_is_inv json_resp = json.loads(response.get_data(as_text=True)) assert response.status_code == 400 assert json_resp['errors'][0]['error'] == 'ValidationError' - assert json_resp['errors'][0]['message'] == 'notification_type unknown is not one of [sms, letter, email]' + assert json_resp['errors'][0]['message'] == 'notification_type unknown is not one of [sms, email]' def test_create_service_data_retention_returns_400_when_data_retention_for_notification_type_already_exists( diff --git a/tests/app/template/test_rest.py b/tests/app/template/test_rest.py index a30756e35..5170290ce 100644 --- a/tests/app/template/test_rest.py +++ b/tests/app/template/test_rest.py @@ -17,18 +17,12 @@ from app.models import ( TemplateHistory, ) from tests import create_admin_authorization_header -from tests.app.db import ( - create_letter_contact, - create_service, - create_template, - create_template_folder, -) +from tests.app.db import create_service, create_template, create_template_folder @pytest.mark.parametrize('template_type, subject', [ (SMS_TYPE, None), (EMAIL_TYPE, 'subject'), - (LETTER_TYPE, 'subject'), ]) def test_should_create_a_new_template_for_a_service( client, sample_user, template_type, subject @@ -473,7 +467,6 @@ def test_should_get_return_all_fields_by_default( 'reply_to', 'reply_to_text', 'service', - 'service_letter_contact', 'subject', 'template_redacted', 'template_type', @@ -759,32 +752,6 @@ def test_update_set_process_type_on_template(client, sample_template): assert template.process_type == 'priority' -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 content', - '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)) - th = TemplateHistory.query.filter_by(id=template.id, version=1).one() - assert th.service_letter_contact_id == letter_contact.id - - @pytest.mark.parametrize('post_data, expected_errors', [ ( {}, @@ -813,58 +780,6 @@ def test_create_template_validates_against_json_schema( assert response['errors'] == expected_errors -@pytest.mark.parametrize('template_default, service_default', - [('template address', 'service address'), - (None, 'service address'), - ('template address', None), - (None, None) - ]) -def test_get_template_reply_to(client, sample_service, template_default, service_default): - auth_header = create_admin_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_update_template_reply_to_set_to_blank(client, notify_db_session): - auth_header = create_admin_authorization_header() - service = create_service(service_permissions=['letter']) - letter_contact = create_letter_contact(service, "Edinburgh, ED1 1AA") - template = create_template(service=service, template_type='letter', reply_to=letter_contact.id) - - data = { - 'reply_to': None, - } - - resp = client.post('/service/{}/template/{}'.format(template.service_id, template.id), - data=json.dumps(data), - headers=[('Content-Type', 'application/json'), auth_header]) - - assert resp.status_code == 200, resp.get_data(as_text=True) - - template = dao_get_template_by_id(template.id) - assert template.service_letter_contact_id is None - th = TemplateHistory.query.filter_by(id=template.id, version=2).one() - assert th.service_letter_contact_id is None - - def test_update_redact_template(admin_request, sample_template): assert sample_template.redact_personalisation is False diff --git a/tests/app/template/test_rest_history.py b/tests/app/template/test_rest_history.py index 47d7d5ac5..3e6f400d2 100644 --- a/tests/app/template/test_rest_history.py +++ b/tests/app/template/test_rest_history.py @@ -5,7 +5,6 @@ from flask import url_for from app.dao.templates_dao import dao_update_template from tests import create_admin_authorization_header -from tests.app.db import create_letter_contact def test_template_history_version(notify_api, sample_user, sample_template): @@ -99,22 +98,3 @@ def test_all_versions_of_template(notify_api, sample_template): 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_reply_to_updates_history(client, sample_letter_template): - auth_header = create_admin_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 diff --git a/tests/app/v2/template/test_get_template.py b/tests/app/v2/template/test_get_template.py index 21dd78145..4503c753f 100644 --- a/tests/app/v2/template/test_get_template.py +++ b/tests/app/v2/template/test_get_template.py @@ -1,10 +1,10 @@ import pytest from flask import json -from app.models import EMAIL_TYPE, LETTER_TYPE, SMS_TYPE, TEMPLATE_TYPES +from app.models import EMAIL_TYPE, SMS_TYPE, TEMPLATE_TYPES from app.utils import DATETIME_FORMAT from tests import create_service_authorization_header -from tests.app.db import create_letter_contact, create_template +from tests.app.db import create_template valid_version_params = [None, 1] @@ -41,7 +41,6 @@ def test_get_template_by_id_returns_200( "subject": expected_subject, 'name': expected_name, 'personalisation': {}, - 'letter_contact_block': None, } assert json_response == expected_response @@ -98,44 +97,6 @@ def test_get_template_by_id_returns_placeholders( assert json_response['personalisation'] == expected_personalisation -@pytest.mark.parametrize("version", valid_version_params) -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_service_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_get_template_with_non_existent_template_id_returns_404(client, fake_uuid, sample_service): auth_header = create_service_authorization_header(service_id=sample_service.id)