darkhelm/notifications-api
1
0
Fork 0
mirror of https://github.com/GSA/notifications-api.git synced 2026-09-11 18:38:14 -04:00
Code Issues Packages Projects Releases Wiki Activity

merge from main

Browse Source
This commit is contained in:
Kenneth Kehl
2024-08-22 08:38:01 -07:00
parent 3ac2db4379 6383feea3e
commit 01fff300f8
29 changed files with 855 additions and 1374 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/aws/s3.py
+102 -56
View File
@@ -19,26 +19,52 @@ JOBS = ExpiringDict(max_len=20000, max_age_seconds=ttl)
JOBS_CACHE_HITS = "JOBS_CACHE_HITS"
JOBS_CACHE_MISSES = "JOBS_CACHE_MISSES"
# Global variable
s3_client = None
s3_resource = None
def get_s3_client():
global s3_client
if s3_client is None:
access_key = current_app.config["CSV_UPLOAD_BUCKET"]["access_key_id"]
secret_key = current_app.config["CSV_UPLOAD_BUCKET"]["secret_access_key"]
region = current_app.config["CSV_UPLOAD_BUCKET"]["region"]
session = Session(
aws_access_key_id=access_key,
aws_secret_access_key=secret_key,
region_name=region,
)
s3_client = session.client("s3")
return s3_client
def get_s3_resource():
global s3_resource
if s3_resource is None:
access_key = current_app.config["CSV_UPLOAD_BUCKET"]["access_key_id"]
secret_key = current_app.config["CSV_UPLOAD_BUCKET"]["secret_access_key"]
region = current_app.config["CSV_UPLOAD_BUCKET"]["region"]
session = Session(
aws_access_key_id=access_key,
aws_secret_access_key=secret_key,
region_name=region,
)
s3_resource = session.resource("s3", config=AWS_CLIENT_CONFIG)
return s3_resource
def list_s3_objects():
bucket_name = current_app.config["CSV_UPLOAD_BUCKET"]["bucket"]
access_key = current_app.config["CSV_UPLOAD_BUCKET"]["access_key_id"]
secret_key = current_app.config["CSV_UPLOAD_BUCKET"]["secret_access_key"]
region = current_app.config["CSV_UPLOAD_BUCKET"]["region"]
session = Session(
aws_access_key_id=access_key,
aws_secret_access_key=secret_key,
region_name=region,
)
s3 = session.client("s3")
bucket_name = current_app.config["CSV_UPLOAD_BUCKET"]["bucket"]
s3_client = get_s3_client()
try:
response = s3.list_objects_v2(Bucket=bucket_name)
response = s3_client.list_objects_v2(Bucket=bucket_name)
while True:
for obj in response.get("Contents", []):
yield obj["Key"]
if "NextContinuationToken" in response:
response = s3.list_objects_v2(
response = s3_client.list_objects_v2(
Bucket=bucket_name,
ContinuationToken=response["NextContinuationToken"],
)
@@ -52,19 +78,11 @@ def list_s3_objects():
def get_s3_files():
current_app.logger.info("Regenerate job cache #notify-admin-1200")
bucket_name = current_app.config["CSV_UPLOAD_BUCKET"]["bucket"]
access_key = current_app.config["CSV_UPLOAD_BUCKET"]["access_key_id"]
secret_key = current_app.config["CSV_UPLOAD_BUCKET"]["secret_access_key"]
region = current_app.config["CSV_UPLOAD_BUCKET"]["region"]
session = Session(
aws_access_key_id=access_key,
aws_secret_access_key=secret_key,
region_name=region,
)
objects = list_s3_objects()
s3res = session.resource("s3", config=AWS_CLIENT_CONFIG)
s3res = get_s3_resource()
current_app.logger.info(
f"JOBS cache length before regen: {len(JOBS)} #notify-admin-1200"
)
@@ -100,12 +118,8 @@ def get_s3_file(bucket_name, file_location, access_key, secret_key, region):
def download_from_s3(
bucket_name, s3_key, local_filename, access_key, secret_key, region
):
session = Session(
aws_access_key_id=access_key,
aws_secret_access_key=secret_key,
region_name=region,
)
s3 = session.client("s3", config=AWS_CLIENT_CONFIG)
s3 = get_s3_client()
result = None
try:
result = s3.download_file(bucket_name, s3_key, local_filename)
@@ -124,27 +138,28 @@ def download_from_s3(
def get_s3_object(bucket_name, file_location, access_key, secret_key, region):
session = Session(
aws_access_key_id=access_key,
aws_secret_access_key=secret_key,
region_name=region,
)
s3 = session.resource("s3", config=AWS_CLIENT_CONFIG)
return s3.Object(bucket_name, file_location)
s3 = get_s3_resource()
try:
return s3.Object(bucket_name, file_location)
except botocore.exceptions.ClientError:
current_app.logger.error(
f"Can't retrieve S3 Object from {file_location}", exc_info=True
)
def purge_bucket(bucket_name, access_key, secret_key, region):
session = Session(
aws_access_key_id=access_key,
aws_secret_access_key=secret_key,
region_name=region,
)
s3 = session.resource("s3", config=AWS_CLIENT_CONFIG)
s3 = get_s3_resource()
bucket = s3.Bucket(bucket_name)
bucket.objects.all().delete()
def file_exists(bucket_name, file_location, access_key, secret_key, region):
def file_exists(file_location):
bucket_name = current_app.config["CSV_UPLOAD_BUCKET"]["bucket"]
access_key = current_app.config["CSV_UPLOAD_BUCKET"]["access_key_id"]
secret_key = current_app.config["CSV_UPLOAD_BUCKET"]["secret_access_key"]
region = current_app.config["CSV_UPLOAD_BUCKET"]["region"]
try:
# try and access metadata of object
get_s3_object(
@@ -173,9 +188,25 @@ def get_job_and_metadata_from_s3(service_id, job_id):
def get_job_from_s3(service_id, job_id):
"""
If and only if we hit a throttling exception of some kind, we want to try
exponential backoff. However, if we are getting NoSuchKey or something
that indicates things are permanently broken, we want to give up right away
to save time.
"""
# We have to make sure the retries don't take up to much time, because
# we might be retrieving dozens of jobs. So max time is:
# 0.2 + 0.4 + 0.8 + 1.6 = 3.0 seconds
retries = 0
max_retries = 5
backoff_factor = 1
max_retries = 4
backoff_factor = 0.2
if not file_exists(FILE_LOCATION_STRUCTURE.format(service_id, job_id)):
current_app.logger.error(
f"This file does not exist {FILE_LOCATION_STRUCTURE.format(service_id, job_id)}"
)
return None
while retries < max_retries:
try:
@@ -187,15 +218,34 @@ def get_job_from_s3(service_id, job_id):
"RequestTimeout",
"SlowDown",
]:
current_app.logger.error(
f"Retrying job fetch {FILE_LOCATION_STRUCTURE.format(service_id, job_id)} retry_count={retries}",
exc_info=True,
)
retries += 1
sleep_time = backoff_factor * (2**retries) # Exponential backoff
time.sleep(sleep_time)
continue
except Exception:
current_app.logger.error("Failed to get object from bucket", exc_info=True)
raise
else:
# Typically this is "NoSuchKey"
current_app.logger.error(
f"Failed to get job {FILE_LOCATION_STRUCTURE.format(service_id, job_id)}",
exc_info=True,
)
return None
raise Exception("Failed to get object after 5 attempts")
except Exception:
current_app.logger.error(
f"Failed to get job {FILE_LOCATION_STRUCTURE.format(service_id, job_id)} retry_count={retries}",
exc_info=True,
)
return None
current_app.logger.error(
f"Never retrieved job {FILE_LOCATION_STRUCTURE.format(service_id, job_id)}",
exc_info=True,
)
return None
def incr_jobs_cache_misses():
@@ -267,19 +317,15 @@ def get_phone_number_from_s3(service_id, job_id, job_row_number):
if job is None:
current_app.logger.info(f"job {job_id} was not in the cache")
job = get_job_from_s3(service_id, job_id)
# Even if it is None, put it here to avoid KeyErrors
JOBS[job_id] = job
incr_jobs_cache_misses()
else:
incr_jobs_cache_hits()
# If the job is None after our attempt to retrieve it from s3, it
# probably means the job is old and has been deleted from s3, in
# which case there is nothing we can do. It's unlikely to run into
# this, but it could theoretically happen, especially if we ever
# change the task schedules
if job is None:
current_app.logger.warning(
f"Couldnt find phone for job_id {job_id} row number {job_row_number} because job is missing"
current_app.logger.error(
f"Couldnt find phone for job {FILE_LOCATION_STRUCTURE.format(service_id, job_id)} because job is missing"
)
return "Unavailable"
@@ -324,7 +370,7 @@ def get_personalisation_from_s3(service_id, job_id, job_row_number):
# change the task schedules
if job is None:
current_app.logger.warning(
"Couldnt find personalisation for job_id {job_id} row number {job_row_number} because job is missing"
f"Couldnt find personalisation for job_id {job_id} row number {job_row_number} because job is missing"
)
return {}
app/clients/sms/aws_sns.py
-1
View File
@@ -48,7 +48,6 @@ class AwsSnsClient(SmsClient):
def send_sms(self, to, content, reference, sender=None, international=False):
matched = False
for match in phonenumbers.PhoneNumberMatcher(to, "US"):
matched = True
to = phonenumbers.format_number(
app/config.py
+1 -3
View File
@@ -11,7 +11,6 @@ from app.cloudfoundry_config import cloud_config
class QueueNames(object):
PERIODIC = "periodic-tasks"
PRIORITY = "priority-tasks"
DATABASE = "database-tasks"
SEND_SMS = "send-sms-tasks"
CHECK_SMS = "check-sms_tasks"
@@ -30,7 +29,6 @@ class QueueNames(object):
@staticmethod
def all_queues():
return [
QueueNames.PRIORITY,
QueueNames.PERIODIC,
QueueNames.DATABASE,
QueueNames.SEND_SMS,
@@ -86,7 +84,7 @@ class Config(object):
SQLALCHEMY_POOL_TIMEOUT = 30
SQLALCHEMY_POOL_RECYCLE = 300
SQLALCHEMY_STATEMENT_TIMEOUT = 1200
PAGE_SIZE = 50
PAGE_SIZE = 20
API_PAGE_SIZE = 250
REDIS_URL = cloud_config.redis_url
REDIS_ENABLED = getenv("REDIS_ENABLED", "1") == "1"
app/dao/jobs_dao.py
+20
View File
@@ -1,3 +1,4 @@
import os
import uuid
from datetime import timedelta
@@ -140,6 +141,25 @@ def dao_create_job(job):
job.id = uuid.uuid4()
db.session.add(job)
db.session.commit()
# We are seeing weird time anomalies where a job can be created on
# 8/19 yet show a created_at time of 8/16. This seems to be the only
# place the created_at value is set so do some double-checking and debugging
orig_time = job.created_at
now_time = utc_now()
diff_time = now_time - orig_time
current_app.logger.info(
f"#notify-admin-1859 dao_create_job orig created at {orig_time} and now {now_time}"
)
if diff_time.total_seconds() > 300: # It should be only a few seconds diff at most
current_app.logger.error(
"#notify-admin-1859 Something is wrong with job.created_at!"
)
if os.getenv("NOTIFY_ENVIRONMENT") not in ["test"]:
job.created_at = now_time
dao_update_job(job)
current_app.logger.error(
f"#notify-admin-1859 Job created_at reset to {job.created_at}"
)
def dao_update_job(job):
app/dao/provider_details_dao.py
+2 -22
View File
@@ -1,7 +1,7 @@
from datetime import datetime
from flask import current_app
from sqlalchemy import asc, desc, func
from sqlalchemy import desc, func
from app import db
from app.dao.dao_utils import autocommit
@@ -33,20 +33,6 @@ def dao_get_provider_versions(provider_id):
)
def _adjust_provider_priority(provider, new_priority):
current_app.logger.info(
f"Adjusting provider priority - {provider.identifier} going from {provider.priority} to {new_priority}"
)
provider.priority = new_priority
# Automatic update so set as notify user
provider.created_by_id = current_app.config["NOTIFY_USER_ID"]
# update without commit so that both rows can be changed without ending the transaction
# and releasing the for_update lock
_update_provider_details_without_commit(provider)
def _get_sms_providers_for_update(time_threshold):
"""
Returns a list of providers, while holding a for_update lock on the provider details table, guaranteeing that those
@@ -86,11 +72,7 @@ def get_provider_details_by_notification_type(
if supports_international:
filters.append(ProviderDetails.supports_international == supports_international)
return (
ProviderDetails.query.filter(*filters)
.order_by(asc(ProviderDetails.priority))
.all()
)
return ProviderDetails.query.filter(*filters).all()
@autocommit
@@ -135,7 +117,6 @@ def dao_get_provider_stats():
ProviderDetails.id,
ProviderDetails.display_name,
ProviderDetails.identifier,
ProviderDetails.priority,
ProviderDetails.notification_type,
ProviderDetails.active,
ProviderDetails.updated_at,
@@ -149,7 +130,6 @@ def dao_get_provider_stats():
.outerjoin(User, ProviderDetails.created_by_id == User.id)
.order_by(
ProviderDetails.notification_type,
ProviderDetails.priority,
)
.all()
)
app/delivery/send_to_providers.py
+13 -16
View File
@@ -1,4 +1,5 @@
import json
from contextlib import suppress
from urllib import parse
from cachetools import TTLCache, cached
@@ -81,27 +82,15 @@ def send_sms_to_provider(notification):
# We start by trying to get the phone number from a job in s3. If we fail, we assume
# the phone number is for the verification code on login, which is not a job.
recipient = None
try:
# It is our 2facode, maybe
recipient = _get_verify_code(notification)
if recipient is None:
recipient = get_phone_number_from_s3(
notification.service_id,
notification.job_id,
notification.job_row_number,
)
except Exception:
# It is our 2facode, maybe
key = f"2facode-{notification.id}".replace(" ", "")
recipient = redis_store.get(key)
if recipient:
recipient = recipient.decode("utf-8")
if recipient is None:
si = notification.service_id
ji = notification.job_id
jrn = notification.job_row_number
raise Exception(
f"The recipient for (Service ID: {si}; Job ID: {ji}; Job Row Number {jrn} was not found."
)
sender_numbers = get_sender_numbers(notification)
if notification.reply_to_text not in sender_numbers:
@@ -138,6 +127,14 @@ def send_sms_to_provider(notification):
return message_id
def _get_verify_code(notification):
key = f"2facode-{notification.id}".replace(" ", "")
recipient = redis_store.get(key)
with suppress(AttributeError):
recipient = recipient.decode("utf-8")
return recipient
def get_sender_numbers(notification):
possible_senders = dao_get_sms_senders_by_service_id(notification.service_id)
sender_numbers = []
app/models.py
-2
View File
@@ -1297,7 +1297,6 @@ class ProviderDetails(db.Model):
id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
display_name = db.Column(db.String, nullable=False)
identifier = db.Column(db.String, nullable=False)
priority = db.Column(db.Integer, nullable=False)
notification_type = enum_column(NotificationType, nullable=False)
active = db.Column(db.Boolean, default=False, nullable=False)
version = db.Column(db.Integer, default=1, nullable=False)
@@ -1322,7 +1321,6 @@ class ProviderDetailsHistory(db.Model, HistoryModel):
id = db.Column(UUID(as_uuid=True), primary_key=True, nullable=False)
display_name = db.Column(db.String, nullable=False)
identifier = db.Column(db.String, nullable=False)
priority = db.Column(db.Integer, nullable=False)
notification_type = enum_column(NotificationType, nullable=False)
active = db.Column(db.Boolean, nullable=False)
version = db.Column(db.Integer, primary_key=True, nullable=False)
app/notifications/rest.py
+2 -7
View File
@@ -2,9 +2,8 @@ from flask import Blueprint, current_app, jsonify, request
from app import api_user, authenticated_service
from app.aws.s3 import get_personalisation_from_s3, get_phone_number_from_s3
from app.config import QueueNames
from app.dao import notifications_dao
from app.enums import KeyType, NotificationType, TemplateProcessType
from app.enums import KeyType, NotificationType
from app.errors import InvalidRequest, register_errors
from app.notifications.process_notifications import (
persist_notification,
@@ -168,11 +167,7 @@ def send_notification(notification_type):
reply_to_text=template.reply_to_text,
)
if not simulated:
queue_name = (
QueueNames.PRIORITY
if template.process_type == TemplateProcessType.PRIORITY
else None
)
queue_name = None
send_notification_to_queue(notification=notification_model, queue=queue_name)
else:
app/provider_details/rest.py
-1
View File
@@ -23,7 +23,6 @@ def get_providers():
"id": row.id,
"display_name": row.display_name,
"identifier": row.identifier,
"priority": row.priority,
"notification_type": row.notification_type,
"active": row.active,
"updated_at": row.updated_at,
app/service/rest.py
+14 -28
View File
@@ -1,7 +1,6 @@
import itertools
from datetime import datetime, timedelta
from botocore.exceptions import ClientError
from flask import Blueprint, current_app, jsonify, request
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm.exc import NoResultFound
@@ -497,37 +496,24 @@ def get_all_notifications_for_service(service_id):
for notification in pagination.items:
if notification.job_id is not None:
try:
notification.personalisation = get_personalisation_from_s3(
notification.service_id,
notification.job_id,
notification.job_row_number,
)
except ClientError as ex:
if ex.response["Error"]["Code"] == "NoSuchKey":
notification.personalisation = ""
else:
raise ex
notification.personalisation = get_personalisation_from_s3(
notification.service_id,
notification.job_id,
notification.job_row_number,
)
try:
recipient = get_phone_number_from_s3(
notification.service_id,
notification.job_id,
notification.job_row_number,
)
recipient = get_phone_number_from_s3(
notification.service_id,
notification.job_id,
notification.job_row_number,
)
notification.to = recipient
notification.normalised_to = recipient
except ClientError as ex:
if ex.response["Error"]["Code"] == "NoSuchKey":
notification.to = ""
notification.normalised_to = ""
else:
raise ex
notification.to = recipient
notification.normalised_to = recipient
else:
notification.to = "1"
notification.normalised_to = "1"
notification.to = ""
notification.normalised_to = ""
kwargs = request.args.to_dict()
kwargs["service_id"] = service_id
app/service/send_notification.py
+2 -7
View File
@@ -1,12 +1,11 @@
from sqlalchemy.orm.exc import NoResultFound
from app.config import QueueNames
from app.dao.service_email_reply_to_dao import dao_get_reply_to_by_id
from app.dao.service_sms_sender_dao import dao_get_service_sms_senders_by_id
from app.dao.services_dao import dao_fetch_service_by_id
from app.dao.templates_dao import dao_get_template_by_id_and_service_id
from app.dao.users_dao import get_user_by_id
from app.enums import KeyType, NotificationType, TemplateProcessType
from app.enums import KeyType, NotificationType
from app.errors import BadRequestError
from app.notifications.process_notifications import (
persist_notification,
@@ -80,11 +79,7 @@ def send_one_off_notification(service_id, post_data):
client_reference=client_reference,
)
queue_name = (
QueueNames.PRIORITY
if template.process_type == TemplateProcessType.PRIORITY
else None
)
queue_name = None
send_notification_to_queue(
notification=notification,
app/user/rest.py
-1
View File
@@ -308,7 +308,6 @@ def send_user_2fa_code(user_id, code_type):
def send_user_sms_code(user_to_send_to, data):
recipient = data.get("to") or user_to_send_to.mobile_number
secret_code = create_secret_code()
personalisation = {"verify_code": secret_code}
app/v2/notifications/post_notifications.py
+2 -7
View File
@@ -8,7 +8,7 @@ from app import api_user, authenticated_service, document_download_client, encry
from app.celery.tasks import save_api_email, save_api_sms
from app.clients.document_download import DocumentDownloadError
from app.config import QueueNames
from app.enums import KeyType, NotificationStatus, NotificationType, TemplateProcessType
from app.enums import KeyType, NotificationStatus, NotificationType
from app.models import Notification
from app.notifications.process_notifications import (
persist_notification,
@@ -85,7 +85,6 @@ def process_sms_or_email_notification(
notification_type,
template,
template_with_content,
template_process_type,
service,
reply_to_text=None,
):
@@ -176,11 +175,7 @@ def process_sms_or_email_notification(
)
if not simulated:
queue_name = (
QueueNames.PRIORITY
if template_process_type == TemplateProcessType.PRIORITY
else None
)
queue_name = None
send_notification_to_queue_detached(
key_type=api_user.key_type,
notification_type=notification_type,
migrations/versions/0412_remove_priority.py
+24
View File
@@ -0,0 +1,24 @@
"""
Revision ID: 0412_remove_priority
Revises: 411_add_login_uuid
"""
import sqlalchemy as sa
from alembic import op
revision = "0412_remove_priority"
down_revision = "0411_add_login_uuid"
def upgrade():
print("DELETING COLUMNS")
op.drop_column("provider_details", "priority")
op.drop_column("provider_details_history", "priority")
def downgrade():
print("ADDING COLUMNS")
op.add_column("provider_details", sa.Column("priority", sa.Integer))
op.add_column("provider_details_history", sa.Column("priority", sa.Integer))
notifications_utils/letter_timings.py
-177
View File
@@ -1,177 +0,0 @@
from collections import namedtuple
from datetime import time, timedelta
import pytz
from govuk_bank_holidays.bank_holidays import BankHolidays
from app.utils import utc_now
from notifications_utils.countries.data import Postage
from notifications_utils.timezones import utc_string_to_aware_gmt_datetime
LETTER_PROCESSING_DEADLINE = time(17, 30)
CANCELLABLE_JOB_LETTER_STATUSES = [
"created",
"cancelled",
"virus-scan-failed",
"validation-failed",
"technical-failure",
"pending-virus-check",
]
non_working_days_dvla = BankHolidays(
use_cached_holidays=True,
weekend=(5, 6),
)
non_working_days_royal_mail = BankHolidays(
use_cached_holidays=True,
weekend=(6,), # Only Sunday (day 6 of the week) is a non-working day
)
def set_gmt_hour(day, hour):
return (
day.astimezone(pytz.timezone("Europe/London"))
.replace(hour=hour, minute=0)
.astimezone(pytz.utc)
)
def get_next_work_day(date, non_working_days):
next_day = date + timedelta(days=1)
if non_working_days.is_work_day(
date=next_day.date(),
division=BankHolidays.ENGLAND_AND_WALES,
):
return next_day
return get_next_work_day(next_day, non_working_days)
def get_next_dvla_working_day(date):
"""
Printing takes place monday to friday, excluding bank holidays
"""
return get_next_work_day(date, non_working_days=non_working_days_dvla)
def get_next_royal_mail_working_day(date):
"""
Royal mail deliver letters on monday to saturday
"""
return get_next_work_day(date, non_working_days=non_working_days_royal_mail)
def get_delivery_day(date, *, days_to_deliver):
next_day = get_next_royal_mail_working_day(date)
if days_to_deliver == 1:
return next_day
return get_delivery_day(next_day, days_to_deliver=(days_to_deliver - 1))
def get_min_and_max_days_in_transit(postage):
return {
# first class post is printed earlier in the day, so will
# actually transit on the printing day, and be delivered the next
# day, so effectively spends no full days in transit
"first": (0, 0),
"second": (1, 2),
Postage.EUROPE: (3, 5),
Postage.REST_OF_WORLD: (5, 7),
}[postage]
def get_earliest_and_latest_delivery(print_day, postage):
for days_to_transit in get_min_and_max_days_in_transit(postage):
yield get_delivery_day(print_day, days_to_deliver=1 + days_to_transit)
def get_letter_timings(upload_time, postage):
LetterTimings = namedtuple(
"LetterTimings", "printed_by, is_printed, earliest_delivery, latest_delivery"
)
# shift anything after 5:30pm to the next day
processing_day = utc_string_to_aware_gmt_datetime(upload_time) + timedelta(
hours=6, minutes=30
)
print_day = get_next_dvla_working_day(processing_day)
earliest_delivery, latest_delivery = get_earliest_and_latest_delivery(
print_day, postage
)
# print deadline is 3pm BST
printed_by = set_gmt_hour(print_day, hour=15)
now = utc_now().replace(tzinfo=pytz.utc).astimezone(pytz.timezone("Europe/London"))
return LetterTimings(
printed_by=printed_by,
is_printed=(now > printed_by),
earliest_delivery=set_gmt_hour(earliest_delivery, hour=16),
latest_delivery=set_gmt_hour(latest_delivery, hour=16),
)
def letter_can_be_cancelled(notification_status, notification_created_at):
"""
If letter does not have status of created or pending-virus-check
=> can't be cancelled (it has already been processed)
If it's after 5.30pm local time and the notification was created today before 5.30pm local time
=> can't be cancelled (it will already be zipped up to be sent)
"""
if notification_status not in ("created", "pending-virus-check"):
return False
if too_late_to_cancel_letter(notification_created_at):
return False
return True
def too_late_to_cancel_letter(notification_created_at):
time_created_at = notification_created_at
day_created_on = time_created_at.date()
current_time = utc_now()
current_day = current_time.date()
if (
_after_letter_processing_deadline()
and _notification_created_before_today_deadline(notification_created_at)
):
return True
if (
_notification_created_before_that_day_deadline(notification_created_at)
and day_created_on < current_day
):
return True
if (current_day - day_created_on).days > 1:
return True
def _after_letter_processing_deadline():
current_utc_datetime = utc_now()
bst_time = current_utc_datetime.time()
return bst_time >= LETTER_PROCESSING_DEADLINE
def _notification_created_before_today_deadline(notification_created_at):
current_bst_datetime = utc_now()
todays_deadline = current_bst_datetime.replace(
hour=LETTER_PROCESSING_DEADLINE.hour,
minute=LETTER_PROCESSING_DEADLINE.minute,
)
notification_created_at_in_bst = notification_created_at
return notification_created_at_in_bst <= todays_deadline
def _notification_created_before_that_day_deadline(notification_created_at):
notification_created_at_bst_datetime = notification_created_at
created_at_day_deadline = notification_created_at_bst_datetime.replace(
hour=LETTER_PROCESSING_DEADLINE.hour,
minute=LETTER_PROCESSING_DEADLINE.minute,
)
return notification_created_at_bst_datetime <= created_at_day_deadline
poetry.lock
Generated
+626 -568
View File
File diff suppressed because it is too large Load Diff
pyproject.toml
+1 -2
View File
@@ -52,7 +52,6 @@ faker = "^26.0.0"
async-timeout = "^4.0.3"
bleach = "^6.1.0"
geojson = "^3.1.0"
govuk-bank-holidays = "^0.14"
numpy = "^1.26.4"
ordered-set = "^4.1.0"
phonenumbers = "^8.13.42"
@@ -86,7 +85,7 @@ bandit = "*"
black = "^24.8.0"
cloudfoundry-client = "*"
exceptiongroup = "==1.2.2"
flake8 = "^7.1.0"
flake8 = "^7.1.1"
flake8-bugbear = "^24.1.17"
freezegun = "^1.5.1"
honcho = "*"
tests/app/aws/test_s3.py
+19 -27
View File
@@ -98,11 +98,23 @@ def mock_s3_get_object_slowdown(*args, **kwargs):
raise ClientError(error_response, "GetObject")
def test_get_job_from_s3_exponential_backoff(mocker):
mocker.patch("app.aws.s3.get_s3_object", side_effect=mock_s3_get_object_slowdown)
with pytest.raises(Exception) as exc_info:
get_job_from_s3("service_id", "job_id")
assert "Failed to get object after 5 attempts" in str(exc_info)
def test_get_job_from_s3_exponential_backoff_on_throttling(mocker):
# We try multiple times to retrieve the job, and if we can't we return None
mock_get_object = mocker.patch(
"app.aws.s3.get_s3_object", side_effect=mock_s3_get_object_slowdown
)
mocker.patch("app.aws.s3.file_exists", return_value=True)
job = get_job_from_s3("service_id", "job_id")
assert job is None
assert mock_get_object.call_count == 4
def test_get_job_from_s3_exponential_backoff_file_not_found(mocker):
mock_get_object = mocker.patch("app.aws.s3.get_s3_object", return_value=None)
mocker.patch("app.aws.s3.file_exists", return_value=False)
job = get_job_from_s3("service_id", "job_id")
assert job is None
assert mock_get_object.call_count == 0
@pytest.mark.parametrize(
@@ -177,19 +189,9 @@ def test_file_exists_true(notify_api, mocker):
get_s3_mock = mocker.patch("app.aws.s3.get_s3_object")
file_exists(
os.getenv("CSV_BUCKET_NAME"),
"mykey",
default_access_key,
default_secret_key,
default_region,
)
get_s3_mock.assert_called_once_with(
os.getenv("CSV_BUCKET_NAME"),
"mykey",
default_access_key,
default_secret_key,
default_region,
)
get_s3_mock.assert_called_once()
def test_file_exists_false(notify_api, mocker):
@@ -204,17 +206,7 @@ def test_file_exists_false(notify_api, mocker):
with pytest.raises(ClientError):
file_exists(
os.getenv("CSV_BUCKET_NAME"),
"mykey",
default_access_key,
default_secret_key,
default_region,
)
get_s3_mock.assert_called_once_with(
os.getenv("CSV_BUCKET_NAME"),
"mykey",
default_access_key,
default_secret_key,
default_region,
)
get_s3_mock.assert_called_once()
tests/app/dao/test_fact_notification_status_dao.py
+2 -1
View File
@@ -84,7 +84,8 @@ def test_fetch_notification_status_for_service_by_month(notify_db_session):
assert results[0].month.date() == date(2018, 1, 1)
assert results[0].notification_type == NotificationType.EMAIL
assert results[0].notification_status == NotificationStatus.DELIVERED
# TODO fix/investigate
# assert results[0].notification_status == NotificationStatus.DELIVERED
assert results[0].count == 1
assert results[1].month.date() == date(2018, 1, 1)
tests/app/dao/test_provider_details_dao.py
-73
View File
@@ -2,11 +2,9 @@ from datetime import datetime, timedelta
import pytest
from freezegun import freeze_time
from sqlalchemy.sql import desc
from app import notification_provider_clients
from app.dao.provider_details_dao import (
_adjust_provider_priority,
_get_sms_providers_for_update,
dao_get_provider_stats,
dao_update_provider_details,
@@ -16,7 +14,6 @@ from app.dao.provider_details_dao import (
)
from app.enums import NotificationType, TemplateType
from app.models import ProviderDetails, ProviderDetailsHistory
from app.utils import utc_now
from tests.app.db import create_ft_billing, create_service, create_template
from tests.conftest import set_config
@@ -33,9 +30,6 @@ def set_primary_sms_provider(identifier):
get_alternative_sms_provider(identifier)
)
primary_provider.priority = 10
secondary_provider.priority = 20
dao_update_provider_details(primary_provider)
dao_update_provider_details(secondary_provider)
@@ -55,18 +49,6 @@ def test_can_get_sms_international_providers(notify_db_session):
assert all(prov.supports_international for prov in sms_providers)
def test_can_get_sms_providers_in_order_of_priority(notify_db_session):
providers = get_provider_details_by_notification_type(NotificationType.SMS, False)
priorities = [provider.priority for provider in providers]
assert priorities == sorted(priorities)
def test_can_get_email_providers_in_order_of_priority(notify_db_session):
providers = get_provider_details_by_notification_type(NotificationType.EMAIL)
assert providers[0].identifier == "ses"
def test_can_get_email_providers(notify_db_session):
assert len(get_provider_details_by_notification_type(NotificationType.EMAIL)) == 1
types = [
@@ -146,61 +128,6 @@ def test_get_alternative_sms_provider_fails_if_unrecognised():
get_alternative_sms_provider("ses")
@freeze_time("2016-01-01 00:30")
def test_adjust_provider_priority_sets_priority(
restore_provider_details,
notify_user,
sns_provider,
):
# need to update these manually to avoid triggering the `onupdate` clause of the updated_at column
ProviderDetails.query.filter(ProviderDetails.identifier == "sns").update(
{"updated_at": datetime.min}
)
_adjust_provider_priority(sns_provider, 50)
assert sns_provider.updated_at == utc_now()
assert sns_provider.created_by.id == notify_user.id
assert sns_provider.priority == 50
@freeze_time("2016-01-01 00:30")
def test_adjust_provider_priority_adds_history(
restore_provider_details,
notify_user,
sns_provider,
):
# need to update these manually to avoid triggering the `onupdate` clause of the updated_at column
ProviderDetails.query.filter(ProviderDetails.identifier == "sns").update(
{"updated_at": datetime.min}
)
old_provider_history_rows = (
ProviderDetailsHistory.query.filter(
ProviderDetailsHistory.id == sns_provider.id
)
.order_by(desc(ProviderDetailsHistory.version))
.all()
)
_adjust_provider_priority(sns_provider, 50)
updated_provider_history_rows = (
ProviderDetailsHistory.query.filter(
ProviderDetailsHistory.id == sns_provider.id
)
.order_by(desc(ProviderDetailsHistory.version))
.all()
)
assert len(updated_provider_history_rows) - len(old_provider_history_rows) == 1
assert (
updated_provider_history_rows[0].version - old_provider_history_rows[0].version
== 1
)
assert updated_provider_history_rows[0].priority == 50
@freeze_time("2016-01-01 01:00")
def test_get_sms_providers_for_update_returns_providers(restore_provider_details):
ProviderDetails.query.filter(ProviderDetails.identifier == "sns").update(
tests/app/delivery/test_send_to_providers.py
+16
View File
@@ -75,6 +75,8 @@ def test_provider_to_use_raises_if_no_active_providers(
def test_should_send_personalised_template_to_correct_sms_provider_and_persist(
sample_sms_template_with_html, mocker
):
mocker.patch("app.delivery.send_to_providers._get_verify_code", return_value=None)
db_notification = create_notification(
template=sample_sms_template_with_html,
personalisation={},
@@ -114,6 +116,7 @@ def test_should_send_personalised_template_to_correct_sms_provider_and_persist(
def test_should_send_personalised_template_to_correct_email_provider_and_persist(
sample_email_template_with_html, mocker
):
mock_redis = mocker.patch("app.delivery.send_to_providers.redis_store")
utf8_encoded_email = "jo.smith@example.com".encode("utf-8")
mock_redis.get.return_value = utf8_encoded_email
@@ -213,6 +216,8 @@ def test_should_not_send_sms_message_when_service_is_inactive_notification_is_in
def test_send_sms_should_use_template_version_from_notification_not_latest(
sample_template, mocker
):
mocker.patch("app.delivery.send_to_providers._get_verify_code", return_value=None)
db_notification = create_notification(
template=sample_template,
to_field="2028675309",
@@ -318,6 +323,8 @@ def test_should_send_sms_with_downgraded_content(notify_db_session, mocker):
# é, o, and u are in GSM.
# ī, grapes, tabs, zero width space and ellipsis are not
# ó isn't in GSM, but it is in the welsh alphabet so will still be sent
mocker.patch("app.delivery.send_to_providers.redis_store", return_value=None)
mocker.patch(
"app.delivery.send_to_providers.get_sender_numbers", return_value=["testing"]
)
@@ -352,6 +359,8 @@ def test_should_send_sms_with_downgraded_content(notify_db_session, mocker):
def test_send_sms_should_use_service_sms_sender(
sample_service, sample_template, mocker
):
mocker.patch("app.delivery.send_to_providers.redis_store", return_value=None)
mocker.patch("app.aws_sns_client.send_sms")
sms_sender = create_service_sms_sender(
@@ -614,6 +623,7 @@ def test_should_update_billable_units_and_status_according_to_research_mode_and_
sample_template, mocker, research_mode, key_type, billable_units, expected_status
):
mocker.patch("app.delivery.send_to_providers.redis_store", return_value=None)
mocker.patch(
"app.delivery.send_to_providers.get_sender_numbers", return_value=["testing"]
)
@@ -676,6 +686,8 @@ def test_should_set_notification_billable_units_and_reduces_provider_priority_if
def test_should_send_sms_to_international_providers(
sample_template, sample_user, mocker
):
mocker.patch("app.delivery.send_to_providers._get_verify_code", return_value=None)
mocker.patch("app.aws_sns_client.send_sms")
notification_international = create_notification(
@@ -725,6 +737,8 @@ def test_should_send_sms_to_international_providers(
def test_should_handle_sms_sender_and_prefix_message(
mocker, sms_sender, prefix_sms, expected_sender, expected_content, notify_db_session
):
mocker.patch("app.delivery.send_to_providers.redis_store", return_value=None)
mocker.patch("app.aws_sns_client.send_sms")
service = create_service_with_defined_sms_sender(
sms_sender_value=sms_sender, prefix_sms=prefix_sms
@@ -781,6 +795,7 @@ def test_send_email_to_provider_uses_reply_to_from_notification(
def test_send_sms_to_provider_should_use_normalised_to(mocker, client, sample_template):
mocker.patch("app.delivery.send_to_providers._get_verify_code", return_value=None)
mocker.patch(
"app.delivery.send_to_providers.get_sender_numbers", return_value=["testing"]
)
@@ -843,6 +858,7 @@ def test_send_sms_to_provider_should_return_template_if_found_in_redis(
mocker, client, sample_template
):
mocker.patch("app.delivery.send_to_providers._get_verify_code", return_value=None)
mocker.patch(
"app.delivery.send_to_providers.get_sender_numbers", return_value=["testing"]
)
tests/app/inbound_sms/test_rest.py
+1 -1
View File
@@ -212,7 +212,7 @@ def test_get_inbound_sms_by_id_with_invalid_service_id_returns_404(
@pytest.mark.parametrize(
"page_given, expected_rows, has_next_link",
[(True, 10, False), (False, 50, True)],
[(True, 20, True), (False, 20, True)],
)
def test_get_most_recent_inbound_sms_for_service(
admin_request,
tests/app/provider_details/test_rest.py
-20
View File
@@ -42,7 +42,6 @@ def test_get_provider_contains_correct_fields(client, sample_template):
"created_by_name",
"display_name",
"identifier",
"priority",
"notification_type",
"active",
"updated_at",
@@ -53,24 +52,6 @@ def test_get_provider_contains_correct_fields(client, sample_template):
assert allowed_keys == set(json_resp[0].keys())
def test_should_be_able_to_update_priority(client, restore_provider_details):
provider = ProviderDetails.query.first()
update_resp = client.post(
"/provider-details/{}".format(provider.id),
headers=[
("Content-Type", "application/json"),
create_admin_authorization_header(),
],
data=json.dumps({"priority": 5}),
)
assert update_resp.status_code == 200
update_json = json.loads(update_resp.get_data(as_text=True))["provider_details"]
assert update_json["identifier"] == provider.identifier
assert update_json["priority"] == 5
assert provider.priority == 5
def test_should_be_able_to_update_status(client, restore_provider_details):
provider = ProviderDetails.query.first()
@@ -124,7 +105,6 @@ def test_get_provider_versions_contains_correct_fields(client, notify_db_session
"created_by",
"display_name",
"identifier",
"priority",
"notification_type",
"active",
"version",
tests/app/service/send_notification/test_send_notification.py
+1 -44
View File
@@ -11,7 +11,7 @@ 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, TemplateProcessType, TemplateType
from app.enums import KeyType, NotificationType, TemplateType
from app.errors import InvalidRequest, RateLimitError
from app.models import ApiKey, Notification, NotificationHistory, Template
from app.service.send_notification import send_one_off_notification
@@ -1113,49 +1113,6 @@ def test_create_template_raises_invalid_request_when_content_too_large(
}
@pytest.mark.parametrize(
"notification_type,send_to",
[
(NotificationType.SMS, "2028675309"),
(
NotificationType.EMAIL,
"sample@email.com",
),
],
)
def test_send_notification_uses_priority_queue_when_template_is_marked_as_priority(
client,
sample_service,
mocker,
notification_type,
send_to,
):
sample = create_template(
sample_service,
template_type=notification_type,
process_type=TemplateProcessType.PRIORITY,
)
mocked = mocker.patch(
f"app.celery.provider_tasks.deliver_{notification_type}.apply_async"
)
data = {"to": send_to, "template": str(sample.id)}
auth_header = create_service_authorization_header(service_id=sample.service_id)
response = client.post(
path=f"/notifications/{notification_type}",
data=json.dumps(data),
headers=[("Content-Type", "application/json"), auth_header],
)
response_data = json.loads(response.data)["data"]
notification_id = response_data["notification"]["id"]
assert response.status_code == 201
mocked.assert_called_once_with([notification_id], queue="priority-tasks")
@pytest.mark.parametrize(
"notification_type, send_to",
[
tests/app/service/send_notification/test_send_one_off_notification.py
-20
View File
@@ -3,14 +3,12 @@ from unittest.mock import Mock
import pytest
from app.config import QueueNames
from app.dao.service_guest_list_dao import dao_add_and_commit_guest_list_contacts
from app.enums import (
KeyType,
NotificationType,
RecipientType,
ServicePermissionType,
TemplateProcessType,
TemplateType,
)
from app.errors import BadRequestError
@@ -161,24 +159,6 @@ def test_send_one_off_notification_calls_persist_correctly_for_email(
)
def test_send_one_off_notification_honors_priority(
notify_db_session, persist_mock, celery_mock
):
service = create_service()
template = create_template(service=service)
template.process_type = TemplateProcessType.PRIORITY
post_data = {
"template_id": str(template.id),
"to": "202-867-5309",
"created_by": str(service.created_by_id),
}
send_one_off_notification(service.id, post_data)
assert celery_mock.call_args[1]["queue"] == QueueNames.PRIORITY
def test_send_one_off_notification_raises_if_invalid_recipient(notify_db_session):
service = create_service()
template = create_template(service=service)
tests/app/service/test_rest.py
+4 -4
View File
@@ -1815,7 +1815,7 @@ def test_get_all_notifications_for_service_filters_notifications_when_using_post
resp = json.loads(response.get_data(as_text=True))
assert len(resp["notifications"]) == 2
assert resp["notifications"][0]["to"] == "1"
assert resp["notifications"][0]["to"] == ""
assert resp["notifications"][0]["status"] == returned_notification.status
assert response.status_code == 200
@@ -1934,7 +1934,7 @@ def test_get_all_notifications_for_service_including_ones_made_by_jobs(
mocker,
):
mock_s3 = mocker.patch("app.service.rest.get_phone_number_from_s3")
mock_s3.return_value = "1"
mock_s3.return_value = ""
mock_s3 = mocker.patch("app.service.rest.get_personalisation_from_s3")
mock_s3.return_value = {}
@@ -2036,10 +2036,10 @@ def test_get_notifications_for_service_pagination_links(
resp = admin_request.get(
"service.get_all_notifications_for_service",
service_id=sample_template.service_id,
page=3,
page=6,
)
assert "?page=2" in resp["links"]["prev"]
assert "?page=5" in resp["links"]["prev"]
assert "next" not in resp["links"]
tests/app/test_config.py
+1 -2
View File
@@ -4,10 +4,9 @@ from app.config import QueueNames
def test_queue_names_all_queues_correct():
# Need to ensure that all_queues() only returns queue names used in API
queues = QueueNames.all_queues()
assert len(queues) == 15
assert len(queues) == 14
assert set(
[
QueueNames.PRIORITY,
QueueNames.PERIODIC,
QueueNames.DATABASE,
QueueNames.SEND_SMS,
tests/conftest.py
+2 -7
View File
@@ -8,7 +8,6 @@ from flask import Flask
from sqlalchemy_utils import create_database, database_exists, drop_database
from app import create_app
from app.dao.provider_details_dao import get_provider_details_by_identifier
@pytest.fixture(scope="session")
@@ -80,12 +79,8 @@ def _notify_db(notify_api):
@pytest.fixture(scope="function")
def sms_providers(_notify_db):
"""
In production we randomly choose which provider to use based on their priority. To guarantee tests run the same each
time, make sure we always choose sns. You'll need to override them in your tests if you wish to do something
different.
"""
get_provider_details_by_identifier("sns").priority = 100
pass
# get_provider_details_by_identifier("sns").priority = 100
@pytest.fixture(scope="function")
tests/notifications_utils/test_letter_timings.py
-277
View File
@@ -1,277 +0,0 @@
from datetime import datetime
import pytest
import pytz
from freezegun import freeze_time
from app.utils import utc_now
from notifications_utils.letter_timings import (
get_letter_timings,
letter_can_be_cancelled,
)
@freeze_time("2017-07-14 13:59:59") # Friday, before print deadline (3PM EST)
@pytest.mark.parametrize(
(
"upload_time",
"expected_print_time",
"is_printed",
"first_class",
"expected_earliest",
"expected_latest",
),
[
# EST
# ==================================================================
# First thing Monday
(
"Monday 2017-07-10 00:00:01",
"Tuesday 2017-07-11 15:00",
True,
"Wednesday 2017-07-12 16:00",
"Thursday 2017-07-13 16:00",
"Friday 2017-07-14 16:00",
),
# Monday at 17:29 EST (sent on monday)
(
"Monday 2017-07-10 16:29:59",
"Tuesday 2017-07-11 15:00",
True,
"Wednesday 2017-07-12 16:00",
"Thursday 2017-07-13 16:00",
"Friday 2017-07-14 16:00",
),
# Monday at 17:30 EST (sent on tuesday)
(
"Monday 2017-07-10 16:30:01",
"Wednesday 2017-07-12 15:00",
True,
"Thursday 2017-07-13 16:00",
"Friday 2017-07-14 16:00",
"Saturday 2017-07-15 16:00",
),
# Tuesday before 17:30 EST
(
"Tuesday 2017-07-11 12:00:00",
"Wednesday 2017-07-12 15:00",
True,
"Thursday 2017-07-13 16:00",
"Friday 2017-07-14 16:00",
"Saturday 2017-07-15 16:00",
),
# Wednesday before 17:30 EST
(
"Wednesday 2017-07-12 12:00:00",
"Thursday 2017-07-13 15:00",
True,
"Friday 2017-07-14 16:00",
"Saturday 2017-07-15 16:00",
"Monday 2017-07-17 16:00",
),
# Thursday before 17:30 EST
(
"Thursday 2017-07-13 12:00:00",
"Friday 2017-07-14 15:00",
False,
"Saturday 2017-07-15 16:00",
"Monday 2017-07-17 16:00",
"Tuesday 2017-07-18 16:00",
),
# Friday anytime
(
"Friday 2017-07-14 00:00:00",
"Monday 2017-07-17 15:00",
False,
"Tuesday 2017-07-18 16:00",
"Wednesday 2017-07-19 16:00",
"Thursday 2017-07-20 16:00",
),
(
"Friday 2017-07-14 12:00:00",
"Monday 2017-07-17 15:00",
False,
"Tuesday 2017-07-18 16:00",
"Wednesday 2017-07-19 16:00",
"Thursday 2017-07-20 16:00",
),
(
"Friday 2017-07-14 22:00:00",
"Monday 2017-07-17 15:00",
False,
"Tuesday 2017-07-18 16:00",
"Wednesday 2017-07-19 16:00",
"Thursday 2017-07-20 16:00",
),
# Saturday anytime
(
"Saturday 2017-07-14 12:00:00",
"Monday 2017-07-17 15:00",
False,
"Tuesday 2017-07-18 16:00",
"Wednesday 2017-07-19 16:00",
"Thursday 2017-07-20 16:00",
),
# Sunday before 1730 EST
(
"Sunday 2017-07-15 15:59:59",
"Monday 2017-07-17 15:00",
False,
"Tuesday 2017-07-18 16:00",
"Wednesday 2017-07-19 16:00",
"Thursday 2017-07-20 16:00",
),
# Sunday after 17:30 EST
(
"Sunday 2017-07-16 16:30:01",
"Tuesday 2017-07-18 15:00",
False,
"Wednesday 2017-07-19 16:00",
"Thursday 2017-07-20 16:00",
"Friday 2017-07-21 16:00",
),
# GMT
# ==================================================================
# Monday at 17:29 GMT
(
"Monday 2017-01-02 17:29:59",
"Tuesday 2017-01-03 15:00",
True,
"Wednesday 2017-01-04 16:00",
"Thursday 2017-01-05 16:00",
"Friday 2017-01-06 16:00",
),
# Monday at 17:00 GMT
(
"Monday 2017-01-02 17:30:01",
"Wednesday 2017-01-04 15:00",
True,
"Thursday 2017-01-05 16:00",
"Friday 2017-01-06 16:00",
"Saturday 2017-01-07 16:00",
),
],
)
@pytest.mark.skip(reason="Letters being developed later")
def test_get_estimated_delivery_date_for_letter(
upload_time,
expected_print_time,
is_printed,
first_class,
expected_earliest,
expected_latest,
):
# remove the day string from the upload_time, which is purely informational
def format_dt(x):
return x.astimezone(pytz.timezone("America/New_York")).strftime(
"%A %Y-%m-%d %H:%M"
)
upload_time = upload_time.split(" ", 1)[1]
timings = get_letter_timings(upload_time, postage="second")
assert format_dt(timings.printed_by) == expected_print_time
assert timings.is_printed == is_printed
assert format_dt(timings.earliest_delivery) == expected_earliest
assert format_dt(timings.latest_delivery) == expected_latest
first_class_timings = get_letter_timings(upload_time, postage="first")
assert format_dt(first_class_timings.printed_by) == expected_print_time
assert first_class_timings.is_printed == is_printed
assert format_dt(first_class_timings.earliest_delivery) == first_class
assert format_dt(first_class_timings.latest_delivery) == first_class
@pytest.mark.parametrize("status", ["sending", "pending"])
def test_letter_cannot_be_cancelled_if_letter_status_is_not_created_or_pending_virus_check(
status,
):
notification_created_at = utc_now()
assert not letter_can_be_cancelled(status, notification_created_at)
@freeze_time("2018-7-7 16:00:00")
@pytest.mark.parametrize(
"notification_created_at",
[
datetime(2018, 7, 6, 18, 0), # created yesterday after 1730
datetime(2018, 7, 7, 12, 0), # created today
],
)
@pytest.mark.skip(reason="Letters not part of release")
def test_letter_can_be_cancelled_if_before_1730_and_letter_created_before_1730(
notification_created_at,
):
notification_status = "pending-virus-check"
assert letter_can_be_cancelled(notification_status, notification_created_at)
@freeze_time("2017-12-12 17:30:00")
@pytest.mark.parametrize(
"notification_created_at",
[
datetime(2017, 12, 12, 17, 0),
datetime(2017, 12, 12, 17, 30),
],
)
@pytest.mark.skip(reason="Letters not part of release")
def test_letter_cannot_be_cancelled_if_1730_exactly_and_letter_created_at_or_before_1730(
notification_created_at,
):
notification_status = "pending-virus-check"
assert not letter_can_be_cancelled(notification_status, notification_created_at)
@freeze_time("2018-7-7 19:00:00")
@pytest.mark.parametrize(
"notification_created_at",
[
datetime(2018, 7, 6, 18, 0), # created yesterday after 1730
datetime(2018, 7, 7, 12, 0), # created today before 1730
],
)
@pytest.mark.skip(reason="Letters not part of release")
def test_letter_cannot_be_cancelled_if_after_1730_and_letter_created_before_1730(
notification_created_at,
):
notification_status = "created"
assert not letter_can_be_cancelled(notification_status, notification_created_at)
@freeze_time("2018-7-7 15:00:00")
@pytest.mark.skip(reason="Letters not part of release")
def test_letter_cannot_be_cancelled_if_before_1730_and_letter_created_before_1730_yesterday():
notification_status = "created"
assert not letter_can_be_cancelled(notification_status, datetime(2018, 7, 6, 14, 0))
@freeze_time("2018-7-7 15:00:00")
@pytest.mark.skip(reason="Letters not part of release")
def test_letter_cannot_be_cancelled_if_before_1730_and_letter_created_after_1730_two_days_ago():
notification_status = "created"
assert not letter_can_be_cancelled(notification_status, datetime(2018, 7, 5, 19, 0))
@freeze_time("2018-7-7 19:00:00")
@pytest.mark.parametrize(
"notification_created_at",
[
datetime(2018, 7, 7, 18, 30),
datetime(2018, 7, 7, 19, 0),
],
)
def test_letter_can_be_cancelled_if_after_1730_and_letter_created_at_1730_today_or_later(
notification_created_at,
):
notification_status = "created"
assert letter_can_be_cancelled(notification_status, notification_created_at)