Merge branch 'master' into stop-populating-mapping-tables

scripts/run_tests.sh

@@ -27,8 +27,7 @@ function display_result {
 if [[ -z "$VIRTUAL_ENV" ]] && [[ -d venv ]]; then
   source ./venv/bin/activate
 fi
-echo -e "\033[31mWARNING. NOT RUNNING flake8 AGAINST TEST DIRECTORY DUE TO LARGE AMOUNT OF EXISTING ISSUES.\033[0m"
+flake8 .
-flake8 app/
 display_result $? 1 "Code style check"
 
 # run with four concurrent threads

tests/app/authentication/test_authentication.py

@@ -9,7 +9,6 @@ import flask
 from flask import json, current_app
 from freezegun import freeze_time
 from notifications_python_client.authentication import create_jwt_token
-from notifications_utils.request_helper import check_proxy_header_before_request
 
 from app import api_user
 from app.dao.api_key_dao import get_unsigned_secrets, save_model_api_key, get_unsigned_secret, expire_api_key
@@ -281,7 +280,7 @@ def test_authentication_returns_error_when_service_has_no_secrets(client,
 
 
 def test_should_attach_the_current_api_key_to_current_app(notify_api, sample_service, sample_api_key):
-    with notify_api.test_request_context() as context, notify_api.test_client() as client:
+    with notify_api.test_request_context(), notify_api.test_client() as client:
         token = __create_token(sample_api_key.service_id)
         response = client.get(
             '/notifications',

tests/app/celery/test_research_mode_tasks.py

@@ -11,8 +11,6 @@ from app.celery.research_mode_tasks import (
     mmg_callback,
     firetext_callback,
     ses_notification_callback,
-    ses_hard_bounce_callback,
-    ses_soft_bounce_callback
 )
 
 

tests/app/celery/test_scheduled_tasks.py

@@ -714,11 +714,8 @@ def test_run_letter_jobs(client, mocker, sample_letter_template):
 
 
 def test_run_letter_jobs_does_nothing_if_no_ready_jobs(client, mocker, sample_letter_template):
-    job_ids = [
+    create_job(sample_letter_template, job_status=JOB_STATUS_IN_PROGRESS)
-        str(create_job(sample_letter_template, job_status=JOB_STATUS_IN_PROGRESS).id),
+    create_job(sample_letter_template, job_status=JOB_STATUS_SENT_TO_DVLA)
-        str(create_job(sample_letter_template, job_status=JOB_STATUS_SENT_TO_DVLA).id)
-    ]
-
     mock_celery = mocker.patch("app.celery.tasks.notify_celery.send_task")
 
     run_letter_jobs()

tests/app/celery/test_statistics_tasks.py

@@ -7,8 +7,13 @@ from app.celery.statistics_tasks import (
 from sqlalchemy.exc import SQLAlchemyError
 from app import create_uuid
 from tests.app.conftest import sample_notification
-from app.models import NOTIFICATION_STATUS_TYPES_COMPLETED, NOTIFICATION_SENT, NOTIFICATION_SENDING, \
+from app.models import (
-    NOTIFICATION_PENDING, NOTIFICATION_CREATED, NOTIFICATION_DELIVERED
+    NOTIFICATION_STATUS_TYPES_COMPLETED,
+    NOTIFICATION_SENDING,
+    NOTIFICATION_PENDING,
+    NOTIFICATION_CREATED,
+    NOTIFICATION_DELIVERED,
+)
 
 
 def test_should_create_initial_job_task_if_notification_is_related_to_a_job(

tests/app/celery/test_tasks.py

@@ -53,7 +53,6 @@ from tests.app.conftest import (
     sample_job as create_sample_job,
     sample_email_template as create_sample_email_template,
     sample_notification as create_sample_notification,
-    sample_letter_job
 )
 from tests.app.db import (
     create_inbound_sms,
@@ -683,7 +682,7 @@ def test_should_update_job_to_sent_to_dvla_in_research_mode_for_letter_job(
     mocker.patch('app.celery.tasks.save_letter.apply_async')
     mocker.patch('app.celery.tasks.create_uuid', return_value=fake_uuid)
     mocker.patch('app.celery.tasks.encryption.encrypt', return_value=test_encrypted_data)
-    mock_dvla_file_task = mocker.patch('app.celery.tasks.build_dvla_file.apply_async')
+    mocker.patch('app.celery.tasks.build_dvla_file.apply_async')
 
     process_job(sample_letter_job.id)
 
@@ -1071,7 +1070,7 @@ def test_build_dvla_file(sample_letter_template, mocker):
     create_notification(template=job.template, job=job)
     create_notification(template=job.template, job=job)
     mocked_upload = mocker.patch("app.celery.tasks.s3upload")
-    mocked_send_task = mocker.patch("app.celery.tasks.notify_celery.send_task")
+    mocker.patch("app.celery.tasks.notify_celery.send_task")
     mocker.patch("app.celery.tasks.LetterDVLATemplate", return_value='dvla|string')
     build_dvla_file(job.id)
 
@@ -1211,16 +1210,14 @@ def test_send_inbound_sms_to_service_retries_if_request_returns_500(notify_api,
                           status_code=500)
         send_inbound_sms_to_service(inbound_sms.id, inbound_sms.service_id)
 
-    exc_msg = 'Unable to send_inbound_sms_to_service for service_id: {} and url: {url}'.format(
-        sample_service.id,
-        url=inbound_api.url
-    )
     assert mocked.call_count == 1
     assert mocked.call_args[1]['queue'] == 'retry-tasks'
 
 
 def test_send_inbound_sms_to_service_retries_if_request_throws_unknown(notify_api, sample_service, mocker):
-    inbound_api = create_service_inbound_api(service=sample_service, url="https://some.service.gov.uk/",
+    create_service_inbound_api(
+        service=sample_service,
+        url="https://some.service.gov.uk/",
         bearer_token="something_unique")
     inbound_sms = create_inbound_sms(service=sample_service, notify_number="0751421", user_number="447700900111",
                                      provider_date=datetime(2017, 6, 20), content="Here is some content")
@@ -1230,10 +1227,6 @@ def test_send_inbound_sms_to_service_retries_if_request_throws_unknown(notify_ap
 
     send_inbound_sms_to_service(inbound_sms.id, inbound_sms.service_id)
 
-    exc_msg = 'Unable to send_inbound_sms_to_service for service_id: {} and url: {url}'.format(
-        sample_service.id,
-        url=inbound_api.url
-    )
     assert mocked.call_count == 1
     assert mocked.call_args[1]['queue'] == 'retry-tasks'
 
@@ -1255,12 +1248,16 @@ def test_send_inbound_sms_to_service_does_not_retries_if_request_returns_404(not
 
 
 def test_check_job_status_task_does_not_raise_error(sample_template):
-    job = create_job(template=sample_template, notification_count=3,
+    create_job(
+        template=sample_template,
+        notification_count=3,
         created_at=datetime.utcnow() - timedelta(hours=2),
         scheduled_for=datetime.utcnow() - timedelta(minutes=31),
         processing_started=datetime.utcnow() - timedelta(minutes=31),
         job_status=JOB_STATUS_FINISHED)
-    job_2 = create_job(template=sample_template, notification_count=3,
+    create_job(
+        template=sample_template,
+        notification_count=3,
         created_at=datetime.utcnow() - timedelta(minutes=31),
         processing_started=datetime.utcnow() - timedelta(minutes=31),
         job_status=JOB_STATUS_FINISHED)
@@ -1406,7 +1403,7 @@ def test_process_incomplete_job_no_job_in_database(mocker, fake_uuid):
     mocker.patch('app.celery.tasks.s3.get_job_from_s3', return_value=load_example_csv('multiple_sms'))
     mock_save_sms = mocker.patch('app.celery.tasks.save_sms.apply_async')
 
-    with pytest.raises(expected_exception=Exception) as e:
+    with pytest.raises(expected_exception=Exception):
         process_incomplete_job(fake_uuid)
 
     assert mock_save_sms.call_count == 0  # There is no job in the db it will not have been called

tests/app/clients/test_mmg.py

@@ -1,5 +1,3 @@
-import json
-
 import pytest
 import requests_mock
 from requests import HTTPError

tests/app/dao/notification_dao/test_letter_api_notification_dao.py

@@ -35,7 +35,7 @@ def test_should_only_get_created_letters(sample_letter_template):
 
 def test_should_only_get_api_letters(sample_letter_template, sample_letter_job):
     api_noti = create_notification(sample_letter_template)
-    job_noti = create_notification(sample_letter_template, job=sample_letter_job)
+    create_notification(sample_letter_template, job=sample_letter_job)
 
     ret = dao_set_created_live_letter_api_notifications_to_pending()
 
@@ -44,7 +44,7 @@ def test_should_only_get_api_letters(sample_letter_template, sample_letter_job):
 
 def test_should_only_get_normal_api_letters(sample_letter_template):
     live_noti = create_notification(sample_letter_template, key_type=KEY_TYPE_NORMAL)
-    test_noti = create_notification(sample_letter_template, key_type=KEY_TYPE_TEST)
+    create_notification(sample_letter_template, key_type=KEY_TYPE_TEST)
 
     ret = dao_set_created_live_letter_api_notifications_to_pending()
 

tests/app/dao/notification_dao/test_notification_dao.py

@@ -1254,7 +1254,7 @@ def test_dao_timeout_notifications_doesnt_affect_letters(sample_letter_template)
 
 
 def test_should_return_notifications_excluding_jobs_by_default(sample_template, sample_job, sample_api_key):
-    with_job = create_notification(sample_template, job=sample_job)
+    create_notification(sample_template, job=sample_job)
     without_job = create_notification(sample_template, api_key=sample_api_key)
 
     include_jobs = get_notifications_for_service(sample_template.service_id, include_jobs=True).items

tests/app/dao/test_api_key_dao.py

@@ -4,7 +4,6 @@ import pytest
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm.exc import NoResultFound
 
-from app import encryption
 from app.dao.api_key_dao import (save_model_api_key,
                                  get_model_api_keys,
                                  get_unsigned_secrets,

tests/app/dao/test_inbound_numbers_dao.py

@@ -1,5 +1,3 @@
-import uuid
-
 import pytest
 from sqlalchemy.exc import IntegrityError
 

tests/app/dao/test_inbound_sms_dao.py

@@ -29,7 +29,7 @@ def test_get_all_inbound_sms_when_none_exist(sample_service):
 
 def test_get_all_inbound_sms_limits_and_orders(sample_service):
     with freeze_time('2017-01-01'):
-        one = create_inbound_sms(sample_service)
+        create_inbound_sms(sample_service)
     with freeze_time('2017-01-03'):
         three = create_inbound_sms(sample_service)
     with freeze_time('2017-01-02'):
@@ -48,7 +48,7 @@ def test_get_all_inbound_sms_filters_on_service(notify_db_session):
     service_two = create_service(service_name='two')
 
     sms_one = create_inbound_sms(service_one)
-    sms_two = create_inbound_sms(service_two)
+    create_inbound_sms(service_two)
 
     res = dao_get_inbound_sms_for_service(service_one.id)
     assert len(res) == 1

tests/app/dao/test_jobs_dao.py

@@ -359,7 +359,7 @@ def test_get_jobs_for_service_doesnt_return_test_messages(
     sample_job,
     file_name,
 ):
-    test_job = create_job(
+    create_job(
         notify_db,
         notify_db_session,
         sample_template.service,

tests/app/dao/test_organisations_dao.py

@@ -1,8 +1,4 @@
-import pytest
-from sqlalchemy.exc import IntegrityError
-
 from app.dao.organisations_dao import (
-    dao_create_organisation,
     dao_get_organisations,
     dao_get_organisation_by_id,
     dao_update_organisation,
@@ -49,7 +45,7 @@ def test_get_organisation_by_id_gets_correct_organisation(notify_db, notify_db_s
 
 def test_update_organisation(notify_db, notify_db_session):
     updated_name = 'new name'
-    organisation = create_organisation()
+    create_organisation()
 
     organisations_1 = Organisation.query.all()
 

tests/app/dao/test_provider_details_dao.py

@@ -67,8 +67,6 @@ def test_can_get_email_providers(restore_provider_details):
 
 
 def test_should_not_error_if_any_provider_in_code_not_in_database(restore_provider_details):
-    providers = ProviderDetails.query.all()
-
     ProviderDetails.query.filter_by(identifier='mmg').delete()
 
     assert clients.get_sms_client('mmg')

tests/app/dao/test_provider_rates_dao.py

@@ -1,4 +1,3 @@
-import uuid
 from datetime import datetime
 from decimal import Decimal
 from app.dao.provider_rates_dao import create_provider_rates

tests/app/dao/test_service_email_reply_to_dao.py

@@ -39,7 +39,7 @@ def test_add_reply_to_email_address_for_service_creates_first_email_for_service(
 
 def test_add_reply_to_email_address_for_service_creates_another_email_for_service(notify_db_session):
     service = create_service()
-    first_reply_to = create_reply_to_email(service=service, email_address="first@address.com")
+    create_reply_to_email(service=service, email_address="first@address.com")
 
     add_reply_to_email_address_for_service(service_id=service.id, email_address='second@address.com', is_default=False)
 
@@ -56,7 +56,7 @@ def test_add_reply_to_email_address_for_service_creates_another_email_for_servic
 
 def test_add_reply_to_email_address_new_reply_to_is_default_existing_reply_to_is_not(notify_db_session):
     service = create_service()
-    first_reply_to = create_reply_to_email(service=service, email_address="first@address.com", is_default=True)
+    create_reply_to_email(service=service, email_address="first@address.com", is_default=True)
     add_reply_to_email_address_for_service(service_id=service.id, email_address='second@address.com', is_default=True)
 
     results = dao_get_reply_to_by_service_id(service_id=service.id)
@@ -121,7 +121,7 @@ def test_update_reply_to_email_address(sample_service):
 
 
 def test_update_reply_to_email_address_set_updated_to_default(sample_service):
-    first_reply_to = create_reply_to_email(service=sample_service, email_address="first@address.com")
+    create_reply_to_email(service=sample_service, email_address="first@address.com")
     second_reply_to = create_reply_to_email(service=sample_service,
                                             email_address="second@address.com",
                                             is_default=False)

tests/app/dao/test_service_sms_sender_dao.py

@@ -121,6 +121,7 @@ def test_dao_update_service_sms_sender_raises_exception_when_no_default_after_up
                                       service_sms_sender_id=sms_sender.id,
                                       is_default=False,
                                       sms_sender="updated")
+    assert 'You must have at least one SMS sender as the default' in str(e.value)
 
 
 def test_update_existing_sms_sender_with_inbound_number(notify_db_session):

tests/app/dao/test_service_whitelist_dao.py

@@ -2,7 +2,8 @@ import uuid
 
 from app.models import (
     ServiceWhitelist,
-    MOBILE_TYPE, EMAIL_TYPE)
+    EMAIL_TYPE,
+)
 
 from app.dao.service_whitelist_dao import (
     dao_fetch_service_whitelist,

tests/app/dao/test_services_dao.py

@@ -590,13 +590,16 @@ def test_fetch_stats_counts_should_ignore_team_key(
 def test_fetch_stats_for_today_only_includes_today(notify_db, notify_db_session, sample_template):
     # two created email, one failed email, and one created sms
     with freeze_time('2001-01-01T23:59:00'):
-        just_before_midnight_yesterday = create_notification(notify_db, None, to_field='1', status='delivered')
+        # just_before_midnight_yesterday
+        create_notification(notify_db, None, to_field='1', status='delivered')
 
     with freeze_time('2001-01-02T00:01:00'):
-        just_after_midnight_today = create_notification(notify_db, None, to_field='2', status='failed')
+        # just_after_midnight_today
+        create_notification(notify_db, None, to_field='2', status='failed')
 
     with freeze_time('2001-01-02T12:00:00'):
-        right_now = create_notification(notify_db, None, to_field='3', status='created')
+        # right_now
+        create_notification(notify_db, None, to_field='3', status='created')
 
         stats = dao_fetch_todays_stats_for_service(sample_template.service_id)
 
@@ -613,14 +616,22 @@ def test_fetch_monthly_historical_stats_separates_months(notify_db, notify_db_se
         notify_db_session,
         sample_template
     )
-    _before_start_of_financial_year = notification_history(created_at=datetime(2016, 3, 31))
+    # _before_start_of_financial_year
-    start_of_financial_year = notification_history(created_at=datetime(2016, 4, 1))
+    notification_history(created_at=datetime(2016, 3, 31))
-    start_of_summer = notification_history(created_at=datetime(2016, 6, 20))
+    # start_of_financial_year
-    start_of_autumn = notification_history(created_at=datetime(2016, 9, 30, 23, 30, 0))  # October because BST
+    notification_history(created_at=datetime(2016, 4, 1))
-    start_of_winter = notification_history(created_at=datetime(2016, 12, 1), status='delivered')
+    # start_of_summer
-    start_of_spring = notification_history(created_at=datetime(2017, 3, 11))
+    notification_history(created_at=datetime(2016, 6, 20))
-    end_of_financial_year = notification_history(created_at=datetime(2017, 3, 31))
+    # start_of_autumn
-    _after_end_of_financial_year = notification_history(created_at=datetime(2017, 3, 31, 23, 30))  # after because BST
+    notification_history(created_at=datetime(2016, 9, 30, 23, 30, 0))  # October because BST
+    # start_of_winter
+    notification_history(created_at=datetime(2016, 12, 1), status='delivered')
+    # start_of_spring
+    notification_history(created_at=datetime(2017, 3, 11))
+    # end_of_financial_year
+    notification_history(created_at=datetime(2017, 3, 31))
+    # _after_end_of_financial_year
+    notification_history(created_at=datetime(2017, 3, 31, 23, 30))  # after because BST
 
     result = dao_fetch_monthly_historical_stats_for_service(sample_template.service_id, 2016)
 
@@ -687,10 +698,12 @@ def test_dao_fetch_todays_stats_for_all_services_includes_all_services(notify_db
 
 def test_dao_fetch_todays_stats_for_all_services_only_includes_today(notify_db, notify_db_session):
     with freeze_time('2001-01-01T23:59:00'):
-        just_before_midnight_yesterday = create_notification(notify_db, None, to_field='1', status='delivered')
+        # just_before_midnight_yesterday
+        create_notification(notify_db, None, to_field='1', status='delivered')
 
     with freeze_time('2001-01-02T00:01:00'):
-        just_after_midnight_today = create_notification(notify_db, None, to_field='2', status='failed')
+        # just_after_midnight_today
+        create_notification(notify_db, None, to_field='2', status='failed')
 
     with freeze_time('2001-01-02T12:00:00'):
         stats = dao_fetch_todays_stats_for_all_services()

tests/app/dao/test_statistics_dao.py

@@ -13,12 +13,18 @@ from app.models import (
     SMS_TYPE,
     EMAIL_TYPE,
     LETTER_TYPE,
+    NOTIFICATION_STATUS_TYPES,
+    NOTIFICATION_CREATED,
     NOTIFICATION_DELIVERED,
+    NOTIFICATION_FAILED,
+    NOTIFICATION_PENDING,
+    NOTIFICATION_PERMANENT_FAILURE,
+    NOTIFICATION_SENDING,
+    NOTIFICATION_SENT,
+    NOTIFICATION_STATUS_SUCCESS,
     NOTIFICATION_TECHNICAL_FAILURE,
     NOTIFICATION_TEMPORARY_FAILURE,
-    NOTIFICATION_PERMANENT_FAILURE,
+)
-    NOTIFICATION_PENDING, NOTIFICATION_CREATED, NOTIFICATION_FAILED, NOTIFICATION_SENT, NOTIFICATION_SENDING,
-    NOTIFICATION_STATUS_TYPES_COMPLETED, Notification, NOTIFICATION_STATUS_TYPES, NOTIFICATION_STATUS_SUCCESS)
 from tests.app.conftest import sample_notification, sample_email_template, sample_template, sample_job, sample_service
 
 

tests/app/dao/test_templates_dao.py

@@ -133,7 +133,7 @@ def test_get_all_templates_for_service(notify_db, notify_db_session, service_fac
     assert len(dao_get_all_templates_for_service(service_1.id)) == 1
     assert len(dao_get_all_templates_for_service(service_2.id)) == 1
 
-    template_1 = create_sample_template(
+    create_sample_template(
         notify_db,
         notify_db_session,
         template_name='Sample Template 1',
@@ -141,7 +141,7 @@ def test_get_all_templates_for_service(notify_db, notify_db_session, service_fac
         content="Template content",
         service=service_1
     )
-    template_2 = create_sample_template(
+    create_sample_template(
         notify_db,
         notify_db_session,
         template_name='Sample Template 2',
@@ -149,7 +149,7 @@ def test_get_all_templates_for_service(notify_db, notify_db_session, service_fac
         content="Template content",
         service=service_1
     )
-    template_3 = create_sample_template(
+    create_sample_template(
         notify_db,
         notify_db_session,
         template_name='Sample Template 3',
@@ -164,7 +164,7 @@ def test_get_all_templates_for_service(notify_db, notify_db_session, service_fac
 
 
 def test_get_all_templates_for_service_is_alphabetised(notify_db, notify_db_session, sample_service):
-    template_1 = create_sample_template(
+    create_sample_template(
         notify_db,
         notify_db_session,
         template_name='Sample Template 1',
@@ -180,7 +180,7 @@ def test_get_all_templates_for_service_is_alphabetised(notify_db, notify_db_sess
         content="Template content",
         service=sample_service
     )
-    template_3 = create_sample_template(
+    create_sample_template(
         notify_db,
         notify_db_session,
         template_name='Sample Template 3',

tests/app/inbound_number/test_rest.py

@@ -38,8 +38,7 @@ def test_rest_get_inbound_number_when_service_is_not_assigned_returns_empty_dict
 def test_rest_set_inbound_number_active_flag_off(
         admin_request, notify_db_session):
     service = create_service(service_name='test service 1')
-    inbound_number = create_inbound_number(
+    create_inbound_number(number='1', provider='mmg', active=True, service_id=service.id)
-        number='1', provider='mmg', active=True, service_id=service.id)
 
     admin_request.post(
         'inbound_number.post_set_inbound_number_off',

tests/app/inbound_sms/test_rest.py

@@ -35,7 +35,7 @@ def test_post_to_get_inbound_sms_with_no_params(admin_request, sample_service):
 
 def test_post_to_get_inbound_sms_with_limit(admin_request, sample_service):
     with freeze_time('2017-01-01'):
-        one = create_inbound_sms(sample_service)
+        create_inbound_sms(sample_service)
     with freeze_time('2017-01-02'):
         two = create_inbound_sms(sample_service)
 
@@ -76,7 +76,7 @@ def test_post_to_get_inbound_sms_should_error_with_invalid_limit(admin_request,
 def test_post_to_get_inbound_sms_filters_user_number(admin_request, sample_service, user_number):
     # user_number in the db is international and normalised
     one = create_inbound_sms(sample_service, user_number='447700900001')
-    two = create_inbound_sms(sample_service, user_number='447700900002')
+    create_inbound_sms(sample_service, user_number='447700900002')
 
     data = {
         'limit': 1,
@@ -97,7 +97,7 @@ def test_post_to_get_inbound_sms_filters_user_number(admin_request, sample_servi
 def test_post_to_get_inbound_sms_filters_international_user_number(admin_request, sample_service):
     # user_number in the db is international and normalised
     one = create_inbound_sms(sample_service, user_number='12025550104')
-    two = create_inbound_sms(sample_service)
+    create_inbound_sms(sample_service)
 
     data = {
         'limit': 1,
@@ -160,7 +160,7 @@ def test_old_get_inbound_sms(admin_request, sample_service):
 
 def test_old_get_inbound_sms_limits(admin_request, sample_service):
     with freeze_time('2017-01-01'):
-        one = create_inbound_sms(sample_service)
+        create_inbound_sms(sample_service)
     with freeze_time('2017-01-02'):
         two = create_inbound_sms(sample_service)
 
@@ -182,7 +182,7 @@ def test_old_get_inbound_sms_limits(admin_request, sample_service):
 def test_old_get_inbound_sms_filters_user_number(admin_request, sample_service, user_number):
     # user_number in the db is international and normalised
     one = create_inbound_sms(sample_service, user_number='447700900001')
-    two = create_inbound_sms(sample_service, user_number='447700900002')
+    create_inbound_sms(sample_service, user_number='447700900002')
 
     sms = admin_request.get(
         'inbound_sms.get_inbound_sms_for_service',
@@ -198,7 +198,7 @@ def test_old_get_inbound_sms_filters_user_number(admin_request, sample_service,
 def test_old_get_inbound_sms_filters_international_user_number(admin_request, sample_service):
     # user_number in the db is international and normalised
     one = create_inbound_sms(sample_service, user_number='12025550104')
-    two = create_inbound_sms(sample_service)
+    create_inbound_sms(sample_service)
 
     sms = admin_request.get(
         'inbound_sms.get_inbound_sms_for_service',

tests/app/invite/test_invite_rest.py

@@ -38,7 +38,7 @@ def test_create_invited_user(admin_request, sample_service, mocker, invitation_e
 
 
 def test_create_invited_user_without_auth_type(admin_request, sample_service, mocker, invitation_email_template):
-    mocked = mocker.patch('app.celery.provider_tasks.deliver_email.apply_async')
+    mocker.patch('app.celery.provider_tasks.deliver_email.apply_async')
     email_address = 'invited_user@service.gov.uk'
     invite_from = sample_service.users[0]
 

tests/app/letters/test_send_letter_jobs.py

@@ -1,5 +1,3 @@
-import uuid
-
 from flask import json
 
 from app.variables import LETTER_TEST_API_FILENAME

tests/app/notifications/rest/test_send_notification.py

@@ -174,7 +174,7 @@ def test_send_notification_with_placeholders_replaced_with_unusual_types(
     expected_body,
     expected_subject,
 ):
-    mocked = mocker.patch('app.celery.provider_tasks.deliver_email.apply_async')
+    mocker.patch('app.celery.provider_tasks.deliver_email.apply_async')
 
     response = client.post(
         path='/notifications/email',

tests/app/notifications/test_receive_notification.py

@@ -1,4 +1,3 @@
-import uuid
 import base64
 from datetime import datetime
 from unittest.mock import call
@@ -6,7 +5,6 @@ from unittest.mock import call
 import pytest
 from flask import json
 
-from app.dao.services_dao import dao_fetch_service_by_inbound_number
 from app.notifications.receive_notifications import (
     format_mmg_message,
     format_mmg_datetime,
@@ -80,7 +78,7 @@ def test_receive_notification_from_mmg_without_permissions_does_not_persist(
     permissions
 ):
     mocked = mocker.patch("app.notifications.receive_notifications.tasks.send_inbound_sms_to_service.apply_async")
-    service = create_service_with_inbound_number(inbound_number='07111111111', service_permissions=permissions)
+    create_service_with_inbound_number(inbound_number='07111111111', service_permissions=permissions)
     data = {
         "ID": "1234",
         "MSISDN": "07111111111",
@@ -113,8 +111,7 @@ def test_receive_notification_from_firetext_without_permissions_does_not_persist
                  return_value=service)
     mocked_send_inbound_sms = mocker.patch(
         "app.notifications.receive_notifications.tasks.send_inbound_sms_to_service.apply_async")
-    mocked_has_permissions = mocker.patch(
+    mocker.patch("app.notifications.receive_notifications.has_inbound_sms_permissions", return_value=False)
-        "app.notifications.receive_notifications.has_inbound_sms_permissions", return_value=False)
 
     data = "source=07999999999&destination=07111111111&message=this is a message&time=2017-01-01 12:00:00"
     response = firetext_post(client, data)
@@ -339,7 +336,7 @@ def test_receive_notification_from_firetext_persists_message(notify_db_session,
 
 def test_receive_notification_from_firetext_persists_message_with_normalized_phone(notify_db_session, client, mocker):
     mocker.patch("app.notifications.receive_notifications.tasks.send_inbound_sms_to_service.apply_async")
-    mock = mocker.patch('app.notifications.receive_notifications.statsd_client.incr')
+    mocker.patch('app.notifications.receive_notifications.statsd_client.incr')
 
     create_service_with_inbound_number(
         inbound_number='07111111111', service_name='b', service_permissions=[EMAIL_TYPE, SMS_TYPE, INBOUND_SMS_TYPE])

tests/app/notifications/test_rest.py

@@ -244,7 +244,7 @@ def test_get_all_notifications_only_returns_notifications_of_matching_type(
 
 
 @pytest.mark.parametrize('key_type', [KEY_TYPE_NORMAL, KEY_TYPE_TEAM, KEY_TYPE_TEST])
-def test_no_api_keys_return_job_notifications_by_default(
+def test_do_not_return_job_notifications_by_default(
     client,
     sample_template,
     sample_job,
@@ -254,7 +254,7 @@ def test_no_api_keys_return_job_notifications_by_default(
     normal_api_key = create_api_key(sample_template.service, KEY_TYPE_NORMAL)
     test_api_key = create_api_key(sample_template.service, KEY_TYPE_TEST)
 
-    job_notification = create_notification(sample_template, job=sample_job)
+    create_notification(sample_template, job=sample_job)
     normal_notification = create_notification(sample_template, api_key=normal_api_key)
     team_notification = create_notification(sample_template, api_key=team_api_key)
     test_notification = create_notification(sample_template, api_key=test_api_key)
@@ -307,7 +307,7 @@ def test_only_normal_api_keys_can_return_job_notifications(
                           key_type=KEY_TYPE_TEST)
     save_model_api_key(test_api_key)
 
-    job_notification = create_sample_notification(
+    create_sample_notification(
         notify_db,
         notify_db_session,
         job=sample_job
@@ -381,8 +381,8 @@ def test_should_reject_invalid_page_param(client, sample_email_template):
 
 def test_valid_page_size_param(notify_api, notify_db, notify_db_session, sample_email_template):
     with notify_api.test_request_context():
-        n1 = create_sample_notification(notify_db, notify_db_session)
+        create_sample_notification(notify_db, notify_db_session)
-        n2 = create_sample_notification(notify_db, notify_db_session)
+        create_sample_notification(notify_db, notify_db_session)
         with notify_api.test_client() as client:
             auth_header = create_authorization_header(service_id=sample_email_template.service_id)
 
@@ -399,8 +399,8 @@ def test_valid_page_size_param(notify_api, notify_db, notify_db_session, sample_
 
 def test_invalid_page_size_param(client, notify_db, notify_db_session, sample_email_template):
 
-    n1 = create_sample_notification(notify_db, notify_db_session)
+    create_sample_notification(notify_db, notify_db_session)
-    n2 = create_sample_notification(notify_db, notify_db_session)
+    create_sample_notification(notify_db, notify_db_session)
     auth_header = create_authorization_header(service_id=sample_email_template.service_id)
 
     response = client.get(
@@ -454,12 +454,12 @@ def test_get_all_notifications_returns_empty_list(client, sample_api_key):
 
 
 def test_filter_by_template_type(client, notify_db, notify_db_session, sample_template, sample_email_template):
-    notification_1 = create_sample_notification(
+    create_sample_notification(
         notify_db,
         notify_db_session,
         service=sample_email_template.service,
         template=sample_template)
-    notification_2 = create_sample_notification(
+    create_sample_notification(
         notify_db,
         notify_db_session,
         service=sample_email_template.service,
@@ -480,8 +480,8 @@ def test_filter_by_template_type(client, notify_db, notify_db_session, sample_te
 def test_filter_by_multiple_template_types(client,
                                            sample_template,
                                            sample_email_template):
-    notification_1 = create_notification(sample_template)
+    create_notification(sample_template)
-    notification_2 = create_notification(sample_email_template)
+    create_notification(sample_email_template)
 
     auth_header = create_authorization_header(service_id=sample_email_template.service_id)
 
@@ -496,8 +496,8 @@ def test_filter_by_multiple_template_types(client,
 
 
 def test_filter_by_status(client, sample_email_template):
-    notification_1 = create_notification(sample_email_template, status="delivered")
+    create_notification(sample_email_template, status="delivered")
-    notification_2 = create_notification(sample_email_template)
+    create_notification(sample_email_template)
 
     auth_header = create_authorization_header(service_id=sample_email_template.service_id)
 
@@ -512,8 +512,8 @@ def test_filter_by_status(client, sample_email_template):
 
 
 def test_filter_by_multiple_statuses(client, sample_email_template):
-    notification_1 = create_notification(sample_email_template, status="delivered")
+    create_notification(sample_email_template, status="delivered")
-    notification_2 = create_notification(sample_email_template, status='sending')
+    create_notification(sample_email_template, status='sending')
 
     auth_header = create_authorization_header(service_id=sample_email_template.service_id)
 
@@ -529,9 +529,9 @@ def test_filter_by_multiple_statuses(client, sample_email_template):
 
 
 def test_filter_by_status_and_template_type(client, sample_template, sample_email_template):
-    notification_1 = create_notification(sample_template)
+    create_notification(sample_template)
-    notification_2 = create_notification(sample_email_template)
+    create_notification(sample_email_template)
-    notification_3 = create_notification(sample_email_template, status="delivered")
+    create_notification(sample_email_template, status="delivered")
 
     auth_header = create_authorization_header(service_id=sample_email_template.service_id)
 

tests/app/organisation/test_rest.py

@@ -1,10 +1,7 @@
-from flask import json
 import pytest
 
 from app.models import Organisation
 
-from tests import create_authorization_header
-
 
 def test_get_organisations(admin_request, notify_db, notify_db_session):
     org1 = Organisation(colour='#FFFFFF', logo='/path/image.png', name='Org1')
@@ -59,7 +56,7 @@ def test_post_create_organisation_without_logo_is_ok(admin_request, notify_db_se
         'name': 'test organisation',
         'colour': '#0000ff',
     }
-    response = admin_request.post(
+    admin_request.post(
         'organisation.create_organisation',
         _data=data,
         _expected_status=201,

tests/app/service/test_rest.py

@@ -77,7 +77,7 @@ def test_get_service_list_with_only_active_flag(client, service_factory):
 
 
 def test_get_service_list_with_user_id_and_only_active_flag(
-        client,
+        admin_request,
         sample_user,
         service_factory
 ):
@@ -85,72 +85,47 @@ def test_get_service_list_with_user_id_and_only_active_flag(
 
     inactive = service_factory.get('one', user=sample_user)
     active = service_factory.get('two', user=sample_user)
-    from_other_user = service_factory.get('three', user=other_user)
+    # from other user
+    service_factory.get('three', user=other_user)
 
     inactive.active = False
 
-    auth_header = create_authorization_header()
+    json_resp = admin_request.get(
-    response = client.get(
+        'service.get_services',
-        '/service?user_id={}&only_active=True'.format(sample_user.id),
+        user_id=sample_user.id,
-        headers=[auth_header]
+        only_active=True
     )
-    assert response.status_code == 200
-    json_resp = json.loads(response.get_data(as_text=True))
     assert len(json_resp['data']) == 1
     assert json_resp['data'][0]['id'] == str(active.id)
 
 
-def test_get_service_list_by_user(client, sample_user, service_factory):
+def test_get_service_list_by_user(admin_request, sample_user, service_factory):
     other_user = create_user(email='foo@bar.gov.uk')
     service_factory.get('one', sample_user)
     service_factory.get('two', sample_user)
     service_factory.get('three', other_user)
 
-    auth_header = create_authorization_header()
+    json_resp = admin_request.get('service.get_services', user_id=sample_user.id)
-    response = client.get(
-        '/service?user_id={}'.format(sample_user.id),
-        headers=[auth_header]
-    )
-    json_resp = json.loads(response.get_data(as_text=True))
-    assert response.status_code == 200
     assert len(json_resp['data']) == 2
     assert json_resp['data'][0]['name'] == 'one'
     assert json_resp['data'][1]['name'] == 'two'
 
 
-def test_get_service_list_by_user_should_return_empty_list_if_no_services(client, sample_service):
+def test_get_service_list_by_user_should_return_empty_list_if_no_services(admin_request, sample_service):
     # service is already created by sample user
     new_user = create_user(email='foo@bar.gov.uk')
 
-    auth_header = create_authorization_header()
+    json_resp = admin_request.get('service.get_services', user_id=new_user.id)
-    response = client.get(
+    assert json_resp['data'] == []
-        '/service?user_id={}'.format(new_user.id),
+
-        headers=[auth_header]
+
-    )
+def test_get_service_list_should_return_empty_list_if_no_services(admin_request):
-    json_resp = json.loads(response.get_data(as_text=True))
+    json_resp = admin_request.get('service.get_services')
-    assert response.status_code == 200
     assert len(json_resp['data']) == 0
 
 
-def test_get_service_list_should_return_empty_list_if_no_services(client):
+def test_get_service_by_id(admin_request, sample_service):
-    auth_header = create_authorization_header()
+    json_resp = admin_request.get('service.get_service_by_id', service_id=sample_service.id)
-    response = client.get(
-        '/service',
-        headers=[auth_header]
-    )
-    assert response.status_code == 200
-    json_resp = json.loads(response.get_data(as_text=True))
-    assert len(json_resp['data']) == 0
-
-
-def test_get_service_by_id(client, sample_service):
-    auth_header = create_authorization_header()
-    resp = client.get(
-        '/service/{}'.format(sample_service.id),
-        headers=[auth_header]
-    )
-    assert resp.status_code == 200
-    json_resp = json.loads(resp.get_data(as_text=True))
     assert json_resp['data']['name'] == sample_service.name
     assert json_resp['data']['id'] == str(sample_service.id)
     assert not json_resp['data']['research_mode']
@@ -161,55 +136,29 @@ def test_get_service_by_id(client, sample_service):
     assert json_resp['data']['prefix_sms'] is True
 
 
-def test_get_service_by_id_returns_free_sms_limit(client, sample_service):
+def test_get_service_by_id_returns_free_sms_limit(admin_request, sample_service):
-
+    json_resp = admin_request.get('service.get_service_by_id', service_id=sample_service.id)
-    auth_header = create_authorization_header()
-    resp = client.get(
-        '/service/{}'.format(sample_service.id),
-        headers=[auth_header]
-    )
-    assert resp.status_code == 200
-    json_resp = json.loads(resp.get_data(as_text=True))
     assert json_resp['data']['free_sms_fragment_limit'] == current_app.config['FREE_SMS_TIER_FRAGMENT_COUNT']
 
 
-def test_get_detailed_service_by_id_returns_free_sms_limit(client, sample_service):
+def test_get_detailed_service_by_id_returns_free_sms_limit(admin_request, sample_service):
-
+    json_resp = admin_request.get('service.get_service_by_id', service_id=sample_service.id, detailed=True)
-    auth_header = create_authorization_header()
-    resp = client.get(
-        '/service/{}?detailed=True'.format(sample_service.id),
-        headers=[auth_header]
-    )
-    assert resp.status_code == 200
-    json_resp = json.loads(resp.get_data(as_text=True))
     assert json_resp['data']['free_sms_fragment_limit'] == current_app.config['FREE_SMS_TIER_FRAGMENT_COUNT']
 
 
-@pytest.mark.parametrize('endpoint', ['/service/{}', '/service/{}?detailed=True'])
+@pytest.mark.parametrize('detailed', [True, False])
-def test_get_service_by_id_returns_organisation_type(client, sample_service, endpoint):
+def test_get_service_by_id_returns_organisation_type(admin_request, sample_service, detailed):
-
+    json_resp = admin_request.get('service.get_service_by_id', service_id=sample_service.id, detailed=detailed)
-    auth_header = create_authorization_header()
-    resp = client.get(
-        endpoint.format(sample_service.id),
-        headers=[auth_header]
-    )
-    assert resp.status_code == 200
-    json_resp = json.loads(resp.get_data(as_text=True))
     assert json_resp['data']['organisation_type'] is None
 
 
-def test_get_service_list_has_default_permissions(client, service_factory):
+def test_get_service_list_has_default_permissions(admin_request, service_factory):
     service_factory.get('one')
     service_factory.get('one')
     service_factory.get('two')
     service_factory.get('three')
-    auth_header = create_authorization_header()
+
-    response = client.get(
+    json_resp = admin_request.get('service.get_services')
-        '/service',
-        headers=[auth_header]
-    )
-    assert response.status_code == 200
-    json_resp = json.loads(response.get_data(as_text=True))
     assert len(json_resp['data']) == 3
     assert all(
         set(
@@ -221,13 +170,8 @@ def test_get_service_list_has_default_permissions(client, service_factory):
     )
 
 
-def test_get_service_by_id_has_default_service_permissions(client, sample_service):
+def test_get_service_by_id_has_default_service_permissions(admin_request, sample_service):
-    auth_header = create_authorization_header()
+    json_resp = admin_request.get('service.get_service_by_id', service_id=sample_service.id)
-    resp = client.get(
-        '/service/{}'.format(sample_service.id),
-        headers=[auth_header]
-    )
-    json_resp = json.loads(resp.get_data(as_text=True))
 
     assert set(
         json_resp['data']['permissions']
@@ -236,17 +180,13 @@ def test_get_service_by_id_has_default_service_permissions(client, sample_servic
     ])
 
 
-def test_get_service_by_id_should_404_if_no_service(notify_api, notify_db):
+def test_get_service_by_id_should_404_if_no_service(admin_request, notify_db_session):
-    with notify_api.test_request_context():
+    json_resp = admin_request.get(
-        with notify_api.test_client() as client:
+        'service.get_service_by_id',
-            service_id = str(uuid.uuid4())
+        service_id=uuid.uuid4(),
-            auth_header = create_authorization_header()
+        _expected_status=404
-            resp = client.get(
-                '/service/{}'.format(service_id),
-                headers=[auth_header]
     )
-            assert resp.status_code == 404
+
-            json_resp = json.loads(resp.get_data(as_text=True))
     assert json_resp['result'] == 'error'
     assert json_resp['message'] == 'No result found'
 
@@ -1385,9 +1325,7 @@ def test_get_notification_for_service(client, notify_db, notify_db_session):
         create_sample_notification(notify_db, notify_db_session, service=service_1),
     ]
 
-    service_2_notifications = [
     create_sample_notification(notify_db, notify_db_session, service=service_2)
-    ]
 
     for notification in service_1_notifications:
         response = client.get(
@@ -1459,7 +1397,8 @@ def test_get_all_notifications_for_service_including_ones_made_by_jobs(
 ):
     with_job = sample_notification_with_job(notify_db, notify_db_session, service=sample_service)
     without_job = create_sample_notification(notify_db, notify_db_session, service=sample_service)
-    from_test_api_key = create_sample_notification(
+    # from_test_api_key
+    create_sample_notification(
         notify_db, notify_db_session, service=sample_service, key_type=KEY_TYPE_TEST
     )
 
@@ -1484,7 +1423,7 @@ def test_get_only_api_created_notifications_for_service(
     sample_job,
     sample_template
 ):
-    with_job = create_notification(sample_template, job=sample_job)
+    create_notification(sample_template, job=sample_job)
     without_job = create_notification(sample_template)
 
     resp = admin_request.get(
@@ -1596,7 +1535,7 @@ def test_get_detailed_service(notify_db, notify_db_session, notify_api, sample_s
     ]
 )
 def test_get_monthly_notification_stats(mocker, client, sample_service, url, expected_status, expected_json):
-    mock_dao = mocker.patch(
+    mocker.patch(
         'app.service.rest.dao_fetch_monthly_historical_stats_for_service',
         return_value={'foo': 'bar'},
     )
@@ -2424,7 +2363,7 @@ def test_get_email_reply_to_addresses_when_there_are_no_reply_to_email_addresses
 
 def test_get_email_reply_to_addresses_with_one_email_address(client, notify_db, notify_db_session):
     service = create_service()
-    reply_to = create_reply_to_email(service, 'test@mail.com')
+    create_reply_to_email(service, 'test@mail.com')
 
     response = client.get('/service/{}/email-reply-to'.format(service.id),
                           headers=[create_authorization_header()])
@@ -2577,7 +2516,7 @@ def test_get_letter_contacts_when_there_are_no_letter_contacts(client, sample_se
 
 def test_get_letter_contacts_with_one_letter_contact(client, notify_db, notify_db_session):
     service = create_service()
-    letter_contact = create_letter_contact(service, 'Aberdeen, AB23 1XH')
+    create_letter_contact(service, 'Aberdeen, AB23 1XH')
 
     response = client.get('/service/{}/letter-contact'.format(service.id),
                           headers=[create_authorization_header()])

tests/app/service/test_statistics.py

@@ -1,8 +1,6 @@
-from datetime import datetime
 import collections
 
 import pytest
-from freezegun import freeze_time
 
 from app.service.statistics import (
     format_statistics,

tests/app/service/test_suspend_resume_service.py

@@ -6,7 +6,7 @@ import uuid
 
 from freezegun import freeze_time
 
-from app.models import Service, ApiKey
+from app.models import Service
 from tests import create_authorization_header
 
 

tests/app/template/test_rest.py

@@ -1,4 +1,3 @@
-import uuid
 import json
 import random
 import string
@@ -17,7 +16,7 @@ from tests.app.conftest import (
     sample_template_without_letter_permission,
     sample_template_without_sms_permission,
 )
-from tests.app.db import create_service, create_letter_contact
+from tests.app.db import create_service, create_letter_contact, create_template
 
 
 @pytest.mark.parametrize('template_type, subject', [
@@ -309,68 +308,18 @@ def test_should_be_able_to_get_all_templates_for_a_service(client, sample_user,
     assert update_json_resp['data'][1]['created_at']
 
 
-def test_should_get_only_templates_for_that_service(client, sample_user, service_factory):
+def test_should_get_only_templates_for_that_service(admin_request, notify_db_session):
+    service_1 = create_service(service_name='service_1')
+    service_2 = create_service(service_name='service_2')
+    id_1 = create_template(service_1).id
+    id_2 = create_template(service_1).id
+    id_3 = create_template(service_2).id
 
-    service_1 = service_factory.get('service 1', email_from='service.1')
+    json_resp_1 = admin_request.get('template.get_all_templates_for_service', service_id=service_1.id)
-    service_2 = service_factory.get('service 2', email_from='service.2')
+    json_resp_2 = admin_request.get('template.get_all_templates_for_service', service_id=service_2.id)
 
-    auth_header_1 = create_authorization_header()
+    assert {template['id'] for template in json_resp_1['data']} == {str(id_1), str(id_2)}
-
+    assert {template['id'] for template in json_resp_2['data']} == {str(id_3)}
-    response_1 = client.get(
-        '/service/{}/template'.format(service_1.id),
-        headers=[auth_header_1]
-    )
-
-    auth_header_2 = create_authorization_header()
-
-    response_2 = client.get(
-        '/service/{}/template'.format(service_2.id),
-        headers=[auth_header_2]
-    )
-
-    assert response_1.status_code == 200
-    assert response_2.status_code == 200
-
-    json_resp_1 = json.loads(response_1.get_data(as_text=True))
-    json_resp_2 = json.loads(response_2.get_data(as_text=True))
-
-    assert len(json_resp_1['data']) == 1
-    assert len(json_resp_2['data']) == 1
-
-    data = {
-        'name': 'my template 2',
-        'template_type': EMAIL_TYPE,
-        'subject': 'subject 2',
-        'content': 'template content',
-        'service': str(service_1.id),
-        'created_by': str(sample_user.id)
-    }
-    data = json.dumps(data)
-    create_auth_header = create_authorization_header()
-    resp = client.post(
-        '/service/{}/template'.format(service_1.id),
-        headers=[('Content-Type', 'application/json'), create_auth_header],
-        data=data
-    )
-
-    response_3 = client.get(
-        '/service/{}/template'.format(service_1.id),
-        headers=[auth_header_1]
-    )
-
-    response_4 = client.get(
-        '/service/{}/template'.format(service_2.id),
-        headers=[auth_header_2]
-    )
-
-    assert response_3.status_code == 200
-    assert response_4.status_code == 200
-
-    json_resp_3 = json.loads(response_3.get_data(as_text=True))
-    json_resp_4 = json.loads(response_4.get_data(as_text=True))
-
-    assert len(json_resp_3['data']) == 2
-    assert len(json_resp_4['data']) == 1
 
 
 @pytest.mark.parametrize(

tests/app/user/test_rest_verify.py

@@ -382,7 +382,6 @@ def test_send_user_email_code_with_urlencoded_next_param(admin_request, mocker,
         _expected_status=204
     )
     noti = Notification.query.one()
-    code = VerifyCode.query.one()
     assert noti.personalisation['url'].endswith('?next=%2Fservices')
 
 

tests/app/v2/notifications/test_get_notifications.py

@@ -7,7 +7,7 @@ from tests import create_authorization_header
 from tests.app.db import (
     create_notification,
     create_template,
-    create_service)
+)
 
 from tests.app.conftest import (
     sample_notification,
@@ -30,7 +30,8 @@ def test_get_notification_by_id_returns_200(
         scheduled_for="2017-05-12 15:15"
     )
 
-    another = create_notification(
+    # another
+    create_notification(
         template=sample_template,
         billable_units=billable_units,
         sent_by=provider,

tests/app/v2/notifications/test_post_notifications.py

@@ -16,6 +16,7 @@ from app.models import Notification
 from app.schema_validation import validate
 from app.v2.errors import RateLimitError
 from app.v2.notifications.notification_schemas import post_sms_response, post_email_response
+from app.v2.notifications.post_notifications import persist_sender_to_notification_mapping
 from tests import create_authorization_header
 from tests.app.conftest import (
     sample_template as create_sample_template,
@@ -623,7 +624,7 @@ def test_post_email_notification_with_valid_reply_to_id_returns_201(client, samp
 
 
 def test_post_email_notification_with_invalid_reply_to_id_returns_400(client, sample_email_template, mocker, fake_uuid):
-    mocked = mocker.patch('app.celery.provider_tasks.deliver_email.apply_async')
+    mocker.patch('app.celery.provider_tasks.deliver_email.apply_async')
     data = {
         "email_address": sample_email_template.service.users[0].email_address,
         "template_id": sample_email_template.id,