Cleaning up tests.

Signed-off-by: Cliff Hill <Clifford.hill@gsa.gov>

tests/app/celery/test_reporting_tasks.py

@@ -13,12 +13,8 @@ from app.celery.reporting_tasks import (
 )
 from app.config import QueueNames
 from app.dao.fact_billing_dao import get_rate
-from app.enums import NotificationType, KeyType
-from app.models import (
-    FactBilling,
-    FactNotificationStatus,
-    Notification,
-)
+from app.enums import KeyType, NotificationType
+from app.models import FactBilling, FactNotificationStatus, Notification
 from tests.app.db import (
     create_notification,
     create_notification_history,

tests/app/conftest.py

@@ -17,7 +17,13 @@ from app.dao.organization_dao import dao_create_organization
 from app.dao.services_dao import dao_add_user_to_service, dao_create_service
 from app.dao.templates_dao import dao_create_template
 from app.dao.users_dao import create_secret_code, create_user_code
-from app.enums import KeyType, NotificationStatus, ServicePermissionType, TemplateType, RecipientType
+from app.enums import (
+    KeyType,
+    NotificationStatus,
+    RecipientType,
+    ServicePermissionType,
+    TemplateType,
+)
 from app.history_meta import create_history
 from app.models import (
     ApiKey,

tests/app/dao/notification_dao/test_notification_dao.py

@@ -536,10 +536,7 @@ def test_get_all_notifications_for_job_by_status(sample_job):
 
     assert len(notifications(filter_dict={"status": status}).items) == 1
 
-    assert (
-        len(notifications(filter_dict={"status": NotificationStatus[:3]}).items)
-        == 3
-    )
+    assert len(notifications(filter_dict={"status": NotificationStatus[:3]}).items) == 3
 
 
 def test_dao_get_notification_count_for_job_id(notify_db_session):

tests/app/dao/notification_dao/test_notification_dao_delete_notifications.py

@@ -8,10 +8,7 @@ from app.dao.notifications_dao import (
     move_notifications_to_notification_history,
 )
 from app.enums import KeyType
-from app.models import (
-    Notification,
-    NotificationHistory,
-)
+from app.models import Notification, NotificationHistory
 from tests.app.db import (
     create_notification,
     create_notification_history,

tests/app/dao/test_fact_notification_status_dao.py

@@ -18,11 +18,7 @@ from app.dao.fact_notification_status_dao import (
     update_fact_notification_status,
 )
 from app.enums import KeyType, NotificationStatus
-from app.models import (
-    FactNotificationStatus,
-    NotificationType,
-    TemplateType,
-)
+from app.models import FactNotificationStatus, NotificationType, TemplateType
 from tests.app.db import (
     create_ft_notification_status,
     create_job,

tests/app/dao/test_invited_user_dao.py

@@ -123,11 +123,21 @@ def test_should_delete_all_invitations_more_than_one_day_old(
     make_invitation(sample_user, sample_service, age=timedelta(hours=48))
     make_invitation(sample_user, sample_service, age=timedelta(hours=48))
     assert (
-        len(InvitedUser.query.filter(InvitedUser.status != InvitedUserStatus.EXPIRED).all()) == 2
+        len(
+            InvitedUser.query.filter(
+                InvitedUser.status != InvitedUserStatus.EXPIRED
+            ).all()
+        )
+        == 2
     )
     expire_invitations_created_more_than_two_days_ago()
     assert (
-        len(InvitedUser.query.filter(InvitedUser.status != InvitedUserStatus.EXPIRED).all()) == 0
+        len(
+            InvitedUser.query.filter(
+                InvitedUser.status != InvitedUserStatus.EXPIRED
+            ).all()
+        )
+        == 0
     )
 
 
@@ -150,11 +160,21 @@ def test_should_not_delete_invitations_less_than_two_days_old(
     )
 
     assert (
-        len(InvitedUser.query.filter(InvitedUser.status != InvitedUserStatus.EXPIRED).all()) == 2
+        len(
+            InvitedUser.query.filter(
+                InvitedUser.status != InvitedUserStatus.EXPIRED
+            ).all()
+        )
+        == 2
     )
     expire_invitations_created_more_than_two_days_ago()
     assert (
-        len(InvitedUser.query.filter(InvitedUser.status != InvitedUserStatus.EXPIRED).all()) == 1
+        len(
+            InvitedUser.query.filter(
+                InvitedUser.status != InvitedUserStatus.EXPIRED
+            ).all()
+        )
+        == 1
     )
     assert (
         InvitedUser.query.filter(InvitedUser.status != InvitedUserStatus.EXPIRED)

tests/app/db.py

@@ -26,7 +26,7 @@ from app.dao.service_sms_sender_dao import (
 from app.dao.services_dao import dao_add_user_to_service, dao_create_service
 from app.dao.templates_dao import dao_create_template, dao_update_template
 from app.dao.users_dao import save_model_user
-from app.enums import KeyType, RecipientType, TemplateType, ServicePermissionType
+from app.enums import KeyType, RecipientType, ServicePermissionType, TemplateType
 from app.models import (
     AnnualBilling,
     ApiKey,

tests/app/notifications/test_receive_notification.py

@@ -5,8 +5,8 @@ from unittest import mock
 import pytest
 from flask import json
 
-from app.models import InboundSms
 from app.enums import ServicePermissionType
+from app.models import InboundSms
 from app.notifications.receive_notifications import (
     create_inbound_sms_object,
     fetch_potential_service,

tests/app/platform_stats/test_rest.py

@@ -3,8 +3,8 @@ from datetime import date, datetime
 import pytest
 from freezegun import freeze_time
 
-from app.errors import InvalidRequest
 from app.enums import TemplateType
+from app.errors import InvalidRequest
 from app.platform_stats.rest import validate_date_range_is_within_a_financial_year
 from tests.app.db import (
     create_ft_billing,

tests/app/service/send_notification/test_send_notification.py

@@ -12,18 +12,9 @@ from app.dao import notifications_dao
 from app.dao.api_key_dao import save_model_api_key
 from app.dao.services_dao import dao_update_service
 from app.dao.templates_dao import dao_get_all_templates_for_service, dao_update_template
+from app.enums import KeyType, NotificationType, TemplateType
 from app.errors import InvalidRequest
-from app.models import (
-    KEY_TYPE_NORMAL,
-    KEY_TYPE_TEAM,
-    KEY_TYPE_TEST,
-    ApiKey,
-    Notification,
-    NotificationHistory,
-    NotificationType,
-    Template,
-    TemplateType,
-)
+from app.models import ApiKey, Notification, NotificationHistory, Template
 from app.service.send_notification import send_one_off_notification
 from app.v2.errors import RateLimitError
 from tests import create_service_authorization_header
@@ -557,7 +548,7 @@ def test_should_not_send_email_if_team_api_key_and_not_a_service_user(
     }
 
     auth_header = create_service_authorization_header(
-        service_id=sample_email_template.service_id, key_type=KEY_TYPE_TEAM
+        service_id=sample_email_template.service_id, key_type=KeyType.TEAM
     )
 
     response = client.post(
@@ -587,7 +578,7 @@ def test_should_not_send_sms_if_team_api_key_and_not_a_service_user(
     }
 
     auth_header = create_service_authorization_header(
-        service_id=sample_template.service_id, key_type=KEY_TYPE_TEAM
+        service_id=sample_template.service_id, key_type=KeyType.TEAM
     )
 
     response = client.post(
@@ -618,7 +609,7 @@ def test_should_send_email_if_team_api_key_and_a_service_user(
         "template": sample_email_template.id,
     }
     auth_header = create_service_authorization_header(
-        service_id=sample_email_template.service_id, key_type=KEY_TYPE_TEAM
+        service_id=sample_email_template.service_id, key_type=KeyType.TEAM
     )
 
     response = client.post(
@@ -650,7 +641,7 @@ def test_should_send_sms_to_anyone_with_test_key(
         service=sample_template.service,
         name="test_key",
         created_by=sample_template.created_by,
-        key_type=KEY_TYPE_TEST,
+        key_type=KeyType.TEST,
     )
     save_model_api_key(api_key)
     auth_header = create_jwt_token(
@@ -688,7 +679,7 @@ def test_should_send_email_to_anyone_with_test_key(
         service=sample_email_template.service,
         name="test_key",
         created_by=sample_email_template.created_by,
-        key_type=KEY_TYPE_TEST,
+        key_type=KeyType.TEST,
     )
     save_model_api_key(api_key)
     auth_header = create_jwt_token(
@@ -726,7 +717,7 @@ def test_should_send_sms_if_team_api_key_and_a_service_user(
         service=sample_template.service,
         name="team_key",
         created_by=sample_template.created_by,
-        key_type=KEY_TYPE_TEAM,
+        key_type=KeyType.TEAM,
     )
     save_model_api_key(api_key)
     auth_header = create_jwt_token(
@@ -784,7 +775,7 @@ def test_should_persist_notification(
         service=template.service,
         name="team_key",
         created_by=template.created_by,
-        key_type=KEY_TYPE_TEAM,
+        key_type=KeyType.TEAM,
     )
     save_model_api_key(api_key)
     auth_header = create_jwt_token(
@@ -843,7 +834,7 @@ def test_should_delete_notification_and_return_error_if_redis_fails(
         service=template.service,
         name="team_key",
         created_by=template.created_by,
-        key_type=KEY_TYPE_TEAM,
+        key_type=KeyType.TEAM,
     )
     save_model_api_key(api_key)
     auth_header = create_jwt_token(
@@ -919,7 +910,7 @@ def test_should_not_persist_notification_or_send_sms_if_simulated_number(
     assert Notification.query.count() == 0
 
 
-@pytest.mark.parametrize("key_type", [KEY_TYPE_NORMAL, KEY_TYPE_TEAM])
+@pytest.mark.parametrize("key_type", [KeyType.NORMAL, KeyType.TEAM])
 @pytest.mark.parametrize(
     "notification_type, to",
     [
@@ -964,7 +955,7 @@ def test_should_not_send_notification_to_non_guest_list_recipient_in_trial_mode(
             "Can’t send to this recipient when service is in trial mode "
             "– see https://www.notifications.service.gov.uk/trial-mode"
         )
-        if key_type == KEY_TYPE_NORMAL
+        if key_type == KeyType.NORMAL
         else ("Can’t send to this recipient using a team-only API key")
     )
 
@@ -976,7 +967,7 @@ def test_should_not_send_notification_to_non_guest_list_recipient_in_trial_mode(
 
 
 @pytest.mark.parametrize("service_restricted", [True, False])
-@pytest.mark.parametrize("key_type", [KEY_TYPE_NORMAL, KEY_TYPE_TEAM])
+@pytest.mark.parametrize("key_type", [KeyType.NORMAL, KeyType.TEAM])
 @pytest.mark.parametrize(
     "notification_type, to, normalized_to",
     [

tests/app/service/send_notification/test_send_one_off_notification.py

@@ -7,15 +7,14 @@ from notifications_utils.recipients import InvalidPhoneError
 
 from app.config import QueueNames
 from app.dao.service_guest_list_dao import dao_add_and_commit_guest_list_contacts
-from app.models import (
-    KEY_TYPE_NORMAL,
-    PRIORITY,
-    GuestListRecipientType,
-    Notification,
+from app.enums import (
+    KeyType,
     NotificationType,
-    ServiceGuestList,
+    RecipientType,
+    TemplateProcessType,
     TemplateType,
 )
+from app.models import Notification, ServiceGuestList
 from app.service.send_notification import send_one_off_notification
 from app.v2.errors import BadRequestError
 from tests.app.db import (
@@ -90,7 +89,7 @@ def test_send_one_off_notification_calls_persist_correctly_for_sms(
         personalisation={"name": "foo"},
         notification_type=NotificationType.SMS,
         api_key_id=None,
-        key_type=KEY_TYPE_NORMAL,
+        key_type=KeyType.NORMAL,
         created_by_id=str(service.created_by_id),
         reply_to_text="testing",
         reference=None,
@@ -147,7 +146,7 @@ def test_send_one_off_notification_calls_persist_correctly_for_email(
         personalisation={"name": "foo"},
         notification_type=NotificationType.EMAIL,
         api_key_id=None,
-        key_type=KEY_TYPE_NORMAL,
+        key_type=KeyType.NORMAL,
         created_by_id=str(service.created_by_id),
         reply_to_text=None,
         reference=None,
@@ -160,7 +159,7 @@ def test_send_one_off_notification_honors_priority(
 ):
     service = create_service()
     template = create_template(service=service)
-    template.process_type = PRIORITY
+    template.process_type = TemplateProcessType.PRIORITY
 
     post_data = {
         "template_id": str(template.id),
@@ -204,7 +203,7 @@ def test_send_one_off_notification_raises_if_cant_send_to_recipient(
     dao_add_and_commit_guest_list_contacts(
         [
             ServiceGuestList.from_string(
-                service.id, GuestListRecipientType.MOBILE, "2028765309"
+                service.id, RecipientType.MOBILE, "2028765309"
             ),
         ]
     )

tests/app/service/test_rest.py

@@ -14,7 +14,7 @@ from app.dao.service_user_dao import dao_get_service_user
 from app.dao.services_dao import dao_add_user_to_service, dao_remove_user_from_service
 from app.dao.templates_dao import dao_redact_template
 from app.dao.users_dao import save_model_user
-from app.enums import KeyType, ServicePermissionType, TemplateType, NotificationType
+from app.enums import KeyType, NotificationType, ServicePermissionType, TemplateType
 from app.models import (
     AnnualBilling,
     EmailBranding,

tests/app/service/test_sender.py

@@ -2,7 +2,8 @@ import pytest
 from flask import current_app
 
 from app.dao.services_dao import dao_add_user_to_service
-from app.models import Notification, NotificationType, TemplateType
+from app.enums import NotificationType, TemplateType
+from app.models import Notification
 from app.service.sender import send_notification_to_service_users
 from tests.app.db import create_service, create_template, create_user
 

tests/app/service/test_service_guest_list.py

@@ -2,7 +2,8 @@ import json
 import uuid
 
 from app.dao.service_guest_list_dao import dao_add_and_commit_guest_list_contacts
-from app.models import GuestListRecipientType, ServiceGuestList
+from app.enums import RecipientType
+from app.models import ServiceGuestList
 from tests import create_admin_authorization_header
 
 
@@ -25,15 +26,15 @@ def test_get_guest_list_separates_emails_and_phones(client, sample_service):
         [
             ServiceGuestList.from_string(
                 sample_service.id,
-                GuestListRecipientType.EMAIL,
+                RecipientType.EMAIL,
                 "service@example.com",
             ),
             ServiceGuestList.from_string(
-                sample_service.id, GuestListRecipientType.MOBILE, "2028675309"
+                sample_service.id, RecipientType.MOBILE, "2028675309"
             ),
             ServiceGuestList.from_string(
                 sample_service.id,
-                GuestListRecipientType.MOBILE,
+                RecipientType.MOBILE,
                 "+1800-555-5555",
             ),
         ]

tests/app/service/test_statistics_rest.py

@@ -4,13 +4,7 @@ from datetime import date, datetime
 import pytest
 from freezegun import freeze_time
 
-from app.models import (
-    KEY_TYPE_NORMAL,
-    KEY_TYPE_TEAM,
-    KEY_TYPE_TEST,
-    NotificationType,
-    TemplateType,
-)
+from app.enums import KeyType, NotificationType, TemplateType
 from tests.app.db import (
     create_ft_notification_status,
     create_notification,
@@ -285,13 +279,13 @@ def test_get_monthly_notification_stats_ignores_test_keys(
     admin_request, sample_service
 ):
     create_ft_notification_status(
-        datetime(2016, 6, 1), service=sample_service, key_type=KEY_TYPE_NORMAL, count=1
+        datetime(2016, 6, 1), service=sample_service, key_type=KeyType.NORMAL, count=1
     )
     create_ft_notification_status(
-        datetime(2016, 6, 1), service=sample_service, key_type=KEY_TYPE_TEAM, count=2
+        datetime(2016, 6, 1), service=sample_service, key_type=KeyType.TEAM, count=2
     )
     create_ft_notification_status(
-        datetime(2016, 6, 1), service=sample_service, key_type=KEY_TYPE_TEST, count=4
+        datetime(2016, 6, 1), service=sample_service, key_type=KeyType.TEST, count=4
     )
 
     response = admin_request.get(

tests/app/service_invite/test_service_invite_rest.py

@@ -7,7 +7,8 @@ from flask import current_app
 from freezegun import freeze_time
 from notifications_utils.url_safe_token import generate_token
 
-from app.models import EMAIL_AUTH_TYPE, SMS_AUTH_TYPE, Notification
+from app.enums import AuthType
+from app.models import Notification
 from tests import create_admin_authorization_header
 from tests.app.db import create_invited_user
 
@@ -39,7 +40,7 @@ def test_create_invited_user(
         email_address=email_address,
         from_user=str(invite_from.id),
         permissions="send_messages,manage_service,manage_api_keys",
-        auth_type=EMAIL_AUTH_TYPE,
+        auth_type=AuthType.EMAIL,
         folder_permissions=["folder_1", "folder_2", "folder_3"],
         **extra_args,
     )
@@ -58,7 +59,7 @@ def test_create_invited_user(
         json_resp["data"]["permissions"]
         == "send_messages,manage_service,manage_api_keys"
     )
-    assert json_resp["data"]["auth_type"] == EMAIL_AUTH_TYPE
+    assert json_resp["data"]["auth_type"] == AuthType.EMAIL
     assert json_resp["data"]["id"]
     assert json_resp["data"]["folder_permissions"] == [
         "folder_1",
@@ -107,7 +108,7 @@ def test_create_invited_user_without_auth_type(
         _expected_status=201,
     )
 
-    assert json_resp["data"]["auth_type"] == SMS_AUTH_TYPE
+    assert json_resp["data"]["auth_type"] == AuthType.SMS
 
 
 def test_create_invited_user_invalid_email(client, sample_service, mocker, fake_uuid):
@@ -161,7 +162,7 @@ def test_get_all_invited_users_by_service(client, notify_db_session, sample_serv
     for invite in json_resp["data"]:
         assert invite["service"] == str(sample_service.id)
         assert invite["from_user"] == str(invite_from.id)
-        assert invite["auth_type"] == SMS_AUTH_TYPE
+        assert invite["auth_type"] == AuthType.SMS
         assert invite["id"]
 
 

tests/app/template/test_rest.py

@@ -9,7 +9,8 @@ from freezegun import freeze_time
 from notifications_utils import SMS_CHAR_COUNT_LIMIT
 
 from app.dao.templates_dao import dao_get_template_by_id, dao_redact_template
-from app.models import ServicePermissionType, Template, TemplateHistory, TemplateType
+from app.enums import ServicePermissionType, TemplateType
+from app.models import Template, TemplateHistory
 from tests import create_admin_authorization_header
 from tests.app.db import create_service, create_template, create_template_folder
 

tests/app/test_model.py

@@ -4,15 +4,14 @@ import pytest
 from freezegun import freeze_time
 from sqlalchemy.exc import IntegrityError
 
+from app import encryption
 from app.enums import (
+    AgreementStatus,
+    AgreementType,
     NotificationStatus,
     RecipientType,
     TemplateType,
-    AgreementStatus,
-    AgreementType,
 )
-
-from app import encryption
 from app.models import (
     Agreement,
     AnnualBilling,
@@ -50,7 +49,7 @@ def test_should_build_service_guest_list_from_mobile_number(mobile_number):
 @pytest.mark.parametrize("email_address", ["test@example.com"])
 def test_should_build_service_guest_list_from_email_address(email_address):
     service_guest_list = ServiceGuestList.from_string(
-        "service_id", GuestListRecipientType.EMAIL, email_address
+        "service_id", RecipientType.EMAIL, email_address
     )
 
     assert service_guest_list.recipient == email_address
@@ -60,8 +59,8 @@ def test_should_build_service_guest_list_from_email_address(email_address):
     "contact, recipient_type",
     [
         ("", None),
-        ("07700dsadsad", GuestListRecipientType.MOBILE),
-        ("gmail.com", GuestListRecipientType.EMAIL),
+        ("07700dsadsad", RecipientType.MOBILE),
+        ("gmail.com", RecipientType.EMAIL),
     ],
 )
 def test_should_not_build_service_guest_list_from_invalid_contact(

tests/app/user/test_rest.py

@@ -9,15 +9,8 @@ from freezegun import freeze_time
 
 from app.dao.permissions_dao import default_service_permissions
 from app.dao.service_user_dao import dao_get_service_user, dao_update_service_user
-from app.models import (
-    EMAIL_AUTH_TYPE,
-    MANAGE_SETTINGS,
-    MANAGE_TEMPLATES,
-    SMS_AUTH_TYPE,
-    Notification,
-    Permission,
-    User,
-)
+from app.enums import AuthType, PermissionType
+from app.models import Notification, Permission, User
 from tests.app.db import (
     create_organization,
     create_service,
@@ -71,7 +64,7 @@ def test_get_user(admin_request, sample_service, sample_organization):
     assert fetched["mobile_number"] == sample_user.mobile_number
     assert fetched["email_address"] == sample_user.email_address
     assert fetched["state"] == sample_user.state
-    assert fetched["auth_type"] == SMS_AUTH_TYPE
+    assert fetched["auth_type"] == AuthType.SMS
     assert fetched["permissions"].keys() == {str(sample_service.id)}
     assert fetched["services"] == [str(sample_service.id)]
     assert fetched["organizations"] == [str(sample_organization.id)]
@@ -117,7 +110,7 @@ def test_post_user(admin_request, notify_db_session):
         "state": "active",
         "failed_login_count": 0,
         "permissions": {},
-        "auth_type": EMAIL_AUTH_TYPE,
+        "auth_type": AuthType.EMAIL,
     }
     json_resp = admin_request.post("user.create_user", _data=data, _expected_status=201)
 
@@ -125,7 +118,7 @@ def test_post_user(admin_request, notify_db_session):
     assert user.check_password("password")
     assert json_resp["data"]["email_address"] == user.email_address
     assert json_resp["data"]["id"] == str(user.id)
-    assert user.auth_type == EMAIL_AUTH_TYPE
+    assert user.auth_type == AuthType.EMAIL
 
 
 def test_post_user_without_auth_type(admin_request, notify_db_session):
@@ -142,7 +135,7 @@ def test_post_user_without_auth_type(admin_request, notify_db_session):
 
     user = User.query.filter_by(email_address="user@digital.fake.gov").first()
     assert json_resp["data"]["id"] == str(user.id)
-    assert user.auth_type == SMS_AUTH_TYPE
+    assert user.auth_type == AuthType.SMS
 
 
 def test_post_user_missing_attribute_email(admin_request, notify_db_session):
@@ -194,12 +187,12 @@ def test_can_create_user_with_email_auth_and_no_mobile(
         "email_address": "user@digital.fake.gov",
         "password": "password",
         "mobile_number": None,
-        "auth_type": EMAIL_AUTH_TYPE,
+        "auth_type": AuthType.EMAIL,
     }
 
     json_resp = admin_request.post("user.create_user", _data=data, _expected_status=201)
 
-    assert json_resp["data"]["auth_type"] == EMAIL_AUTH_TYPE
+    assert json_resp["data"]["auth_type"] == AuthType.EMAIL
     assert json_resp["data"]["mobile_number"] is None
 
 
@@ -211,7 +204,7 @@ def test_cannot_create_user_with_sms_auth_and_no_mobile(
         "email_address": "user@digital.fake.gov",
         "password": "password",
         "mobile_number": None,
-        "auth_type": SMS_AUTH_TYPE,
+        "auth_type": AuthType.SMS,
     }
 
     json_resp = admin_request.post("user.create_user", _data=data, _expected_status=400)
@@ -228,7 +221,7 @@ def test_cannot_create_user_with_empty_strings(admin_request, notify_db_session)
         "email_address": "",
         "password": "password",
         "mobile_number": "",
-        "auth_type": EMAIL_AUTH_TYPE,
+        "auth_type": AuthType.EMAIL,
     }
     resp = admin_request.post("user.create_user", _data=data, _expected_status=400)
     assert resp["message"] == {
@@ -465,21 +458,27 @@ def test_set_user_permissions(admin_request, sample_user, sample_service):
         "user.set_permissions",
         user_id=str(sample_user.id),
         service_id=str(sample_service.id),
-        _data={"permissions": [{"permission": MANAGE_SETTINGS}]},
+        _data={
+            "permissions": [
+                {"permission": PermissionType.PermissionType.MANAGE_SETTINGS}
+            ]
+        },
         _expected_status=204,
     )
 
-    permission = Permission.query.filter_by(permission=MANAGE_SETTINGS).first()
+    permission = Permission.query.filter_by(
+        permission=PermissionType.MANAGE_SETTINGS
+    ).first()
     assert permission.user == sample_user
     assert permission.service == sample_service
-    assert permission.permission == MANAGE_SETTINGS
+    assert permission.permission == PermissionType.MANAGE_SETTINGS
 
 
 def test_set_user_permissions_multiple(admin_request, sample_user, sample_service):
     data = {
         "permissions": [
-            {"permission": MANAGE_SETTINGS},
-            {"permission": MANAGE_TEMPLATES},
+            {"permission": PermissionType.MANAGE_SETTINGS},
+            {"permission": PermissionType.MANAGE_TEMPLATES},
         ]
     }
     admin_request.post(
@@ -490,18 +489,22 @@ def test_set_user_permissions_multiple(admin_request, sample_user, sample_servic
         _expected_status=204,
     )
 
-    permission = Permission.query.filter_by(permission=MANAGE_SETTINGS).first()
+    permission = Permission.query.filter_by(
+        permission=PermissionType.MANAGE_SETTINGS
+    ).first()
     assert permission.user == sample_user
     assert permission.service == sample_service
-    assert permission.permission == MANAGE_SETTINGS
-    permission = Permission.query.filter_by(permission=MANAGE_TEMPLATES).first()
+    assert permission.permission == PermissionType.MANAGE_SETTINGS
+    permission = Permission.query.filter_by(
+        permission=PermissionType.MANAGE_TEMPLATES
+    ).first()
     assert permission.user == sample_user
     assert permission.service == sample_service
-    assert permission.permission == MANAGE_TEMPLATES
+    assert permission.permission == PermissionType.MANAGE_TEMPLATES
 
 
 def test_set_user_permissions_remove_old(admin_request, sample_user, sample_service):
-    data = {"permissions": [{"permission": MANAGE_SETTINGS}]}
+    data = {"permissions": [{"permission": PermissionType.MANAGE_SETTINGS}]}
 
     admin_request.post(
         "user.set_permissions",
@@ -513,7 +516,7 @@ def test_set_user_permissions_remove_old(admin_request, sample_user, sample_serv
 
     query = Permission.query.filter_by(user=sample_user)
     assert query.count() == 1
-    assert query.first().permission == MANAGE_SETTINGS
+    assert query.first().permission == PermissionType.MANAGE_SETTINGS
 
 
 def test_set_user_folder_permissions(admin_request, sample_user, sample_service):
@@ -893,23 +896,23 @@ def test_update_user_auth_type(admin_request, sample_user):
 
 
 def test_can_set_email_auth_and_remove_mobile_at_same_time(admin_request, sample_user):
-    sample_user.auth_type = SMS_AUTH_TYPE
+    sample_user.auth_type = AuthType.SMS
 
     admin_request.post(
         "user.update_user_attribute",
         user_id=sample_user.id,
         _data={
             "mobile_number": None,
-            "auth_type": EMAIL_AUTH_TYPE,
+            "auth_type": AuthType.EMAIL,
         },
     )
 
     assert sample_user.mobile_number is None
-    assert sample_user.auth_type == EMAIL_AUTH_TYPE
+    assert sample_user.auth_type == AuthType.EMAIL
 
 
 def test_cannot_remove_mobile_if_sms_auth(admin_request, sample_user):
-    sample_user.auth_type = SMS_AUTH_TYPE
+    sample_user.auth_type = AuthType.SMS
 
     json_resp = admin_request.post(
         "user.update_user_attribute",
@@ -925,7 +928,7 @@ def test_cannot_remove_mobile_if_sms_auth(admin_request, sample_user):
 
 
 def test_can_remove_mobile_if_email_auth(admin_request, sample_user):
-    sample_user.auth_type = EMAIL_AUTH_TYPE
+    sample_user.auth_type = AuthType.EMAIL
 
     admin_request.post(
         "user.update_user_attribute",
@@ -939,7 +942,7 @@ def test_can_remove_mobile_if_email_auth(admin_request, sample_user):
 def test_cannot_update_user_with_mobile_number_as_empty_string(
     admin_request, sample_user
 ):
-    sample_user.auth_type = EMAIL_AUTH_TYPE
+    sample_user.auth_type = AuthType.EMAIL
 
     resp = admin_request.post(
         "user.update_user_attribute",

tests/app/user/test_rest_verify.py

@@ -10,7 +10,8 @@ import app.celery.tasks
 from app import db
 from app.dao.services_dao import dao_fetch_service_by_id
 from app.dao.users_dao import create_user_code
-from app.models import USER_AUTH_TYPES, Notification, User, VerifyCode, VerifyCodeType
+from app.enums import AuthType, CodeType
+from app.models import Notification, User, VerifyCode
 from tests import create_admin_authorization_header
 
 
@@ -96,7 +97,7 @@ def test_user_verify_code_rejects_good_code_if_too_many_failed_logins(
 
 
 @freeze_time("2020-04-01 12:00")
-@pytest.mark.parametrize("code_type", [VerifyCodeType.EMAIL, VerifyCodeType.SMS])
+@pytest.mark.parametrize("code_type", [CodeType.EMAIL, CodeType.SMS])
 def test_user_verify_code_expired_code_and_increments_failed_login_count(
     code_type, admin_request, sample_user
 ):
@@ -425,7 +426,7 @@ def test_reset_failed_login_count_returns_404_when_user_does_not_exist(client):
 
 
 # we send sms_auth users and webauthn_auth users email code to validate their email access
-@pytest.mark.parametrize("auth_type", USER_AUTH_TYPES)
+@pytest.mark.parametrize("auth_type", AuthType)
 @pytest.mark.parametrize(
     "data, expected_auth_url",
     (
@@ -514,13 +515,13 @@ def test_send_email_code_returns_404_for_bad_input_data(admin_request):
 
 @freeze_time("2016-01-01T12:00:00")
 # we send sms_auth and webauthn_auth users email code to validate their email access
-@pytest.mark.parametrize("auth_type", USER_AUTH_TYPES)
+@pytest.mark.parametrize("auth_type", AuthType)
 def test_user_verify_email_code(admin_request, sample_user, auth_type):
     sample_user.logged_in_at = datetime.utcnow() - timedelta(days=1)
     sample_user.email_access_validated_at = datetime.utcnow() - timedelta(days=1)
     sample_user.auth_type = auth_type
     magic_code = str(uuid.uuid4())
-    verify_code = create_user_code(sample_user, magic_code, VerifyCodeType.EMAIL)
+    verify_code = create_user_code(sample_user, magic_code, CodeType.EMAIL)
 
     data = {"code_type": "email", "code": magic_code}
 
@@ -537,7 +538,7 @@ def test_user_verify_email_code(admin_request, sample_user, auth_type):
     assert sample_user.current_session_id is not None
 
 
-@pytest.mark.parametrize("code_type", [VerifyCodeType.EMAIL, VerifyCodeType.SMS])
+@pytest.mark.parametrize("code_type", [CodeType.EMAIL, CodeType.SMS])
 @freeze_time("2016-01-01T12:00:00")
 def test_user_verify_email_code_fails_if_code_already_used(
     admin_request, sample_user, code_type

tests/app/v2/notifications/test_notification_schemas.py

@@ -5,7 +5,7 @@ from flask import json
 from freezegun import freeze_time
 from jsonschema import ValidationError
 
-from app.models import NOTIFICATION_CREATED, TemplateType
+from app.enums import NotificationStatus, TemplateType
 from app.schema_validation import validate
 from app.v2.notifications.notification_schemas import get_notifications_request
 from app.v2.notifications.notification_schemas import (
@@ -19,7 +19,7 @@ valid_get_json = {}
 
 valid_get_with_optionals_json = {
     "reference": "test reference",
-    "status": [NOTIFICATION_CREATED],
+    "status": [NotificationStatus.CREATED],
     "template_type": [TemplateType.EMAIL],
     "include_jobs": "true",
     "older_than": "a5149c32-f03b-4711-af49-ad6993797d45",

tests/app/v2/template/test_get_template.py

@@ -1,7 +1,7 @@
 import pytest
 from flask import json
 
-from app.models import TemplateType
+from app.enums import TemplateType
 from app.utils import DATETIME_FORMAT
 from tests import create_service_authorization_header
 from tests.app.db import create_template

tests/app/v2/template/test_template_schemas.py

@@ -4,7 +4,7 @@ import pytest
 from flask import json
 from jsonschema.exceptions import ValidationError
 
-from app.models import TemplateType
+from app.enums import TemplateType
 from app.schema_validation import validate
 from app.v2.template.template_schemas import (
     get_template_by_id_request,

tests/app/v2/templates/test_templates_schemas.py

@@ -4,7 +4,7 @@ import pytest
 from flask import json
 from jsonschema.exceptions import ValidationError
 
-from app.models import TemplateType
+from app.enums import TemplateType
 from app.schema_validation import validate
 from app.v2.templates.templates_schemas import (
     get_all_template_request,