remove service letter contact model

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")

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)

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

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
 ):

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(

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(

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 <b>content</b>',
-        'service': str(service.id),
-        'created_by': str(sample_user.id),
-        'reply_to': str(letter_contact.id),
-    }
-
-    json_resp = admin_request.post('template.create_template', service_id=service.id, _data=data, _expected_status=201)
-
-    assert json_resp['data']['template_type'] == 'letter'
-    assert json_resp['data']['reply_to'] == str(letter_contact.id)
-    assert json_resp['data']['reply_to_text'] == letter_contact.contact_block
-
-    template = Template.query.get(json_resp['data']['id'])
-    from app.schemas import template_schema
-    assert sorted(json_resp['data']) == sorted(template_schema.dump(template))
-    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
 

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

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)