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

try deactivating some letter routes

Browse Source
This commit is contained in:
stvnrlly
2022-12-08 09:55:21 -05:00
parent 14a1d499fa
commit 33bd3b3a31
7 changed files with 22 additions and 295 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
tests/app/celery/test_nightly_tasks.py
View File

@@ -112,25 +112,6 @@ def test_will_remove_csv_files_for_jobs_older_than_retention_period(
], any_order=True)
@freeze_time('2017-01-01 10:00:00')
def test_remove_csv_files_filters_by_type(mocker, sample_service):
mocker.patch('app.celery.nightly_tasks.s3.remove_job_from_s3')
"""
Jobs older than seven days are deleted, but only two day's worth (two-day window)
"""
letter_template = create_template(service=sample_service, template_type=LETTER_TYPE)
sms_template = create_template(service=sample_service, template_type=SMS_TYPE)
eight_days_ago = datetime.utcnow() - timedelta(days=8)
job_to_delete = create_job(template=letter_template, created_at=eight_days_ago)
create_job(template=sms_template, created_at=eight_days_ago)
assert s3.remove_job_from_s3.call_args_list == [
call(job_to_delete.service_id, job_to_delete.id),
]
def test_delete_sms_notifications_older_than_retention_calls_child_task(notify_api, mocker):
mocked = mocker.patch('app.celery.nightly_tasks._delete_notifications_older_than_retention_by_type')
delete_sms_notifications_older_than_retention()

6
tests/app/celery/test_reporting_tasks.py
View File

@@ -87,10 +87,8 @@ def test_create_nightly_notification_status_triggers_tasks(
@freeze_time('2019-08-01T00:30')
@pytest.mark.parametrize('notification_date, expected_types_aggregated', [
('2019-08-01', set()),
('2019-07-31', {EMAIL_TYPE, SMS_TYPE, LETTER_TYPE}),
('2019-07-28', {EMAIL_TYPE, SMS_TYPE, LETTER_TYPE}),
('2019-07-27', {LETTER_TYPE}),
('2019-07-22', {LETTER_TYPE}),
('2019-07-31', {EMAIL_TYPE, SMS_TYPE}),
('2019-07-28', {EMAIL_TYPE, SMS_TYPE}),
('2019-07-21', set()),
])
def test_create_nightly_notification_status_triggers_relevant_tasks(

132
tests/app/service/send_notification/test_send_pdf_letter_notification.py
View File

@@ -1,132 +0,0 @@
import pytest
from freezegun import freeze_time
from notifications_utils.s3 import S3ObjectNotFound
from app.dao.notifications_dao import get_notification_by_id
from app.models import EMAIL_TYPE, LETTER_TYPE, UPLOAD_LETTERS
from app.service.send_notification import send_pdf_letter_notification
from app.v2.errors import BadRequestError, TooManyRequestsError
from tests.app.db import create_service
@pytest.fixture
def post_data(sample_service_full_permissions, fake_uuid):
return {
'filename': 'valid.pdf',
'created_by': sample_service_full_permissions.users[0].id,
'file_id': fake_uuid,
'postage': 'second',
'recipient_address': 'Bugs%20Bunny%0A123%20Main%20Street%0ALooney%20Town'
}
@pytest.mark.parametrize('permissions', [
[EMAIL_TYPE],
[UPLOAD_LETTERS],
])
def test_send_pdf_letter_notification_raises_error_if_service_does_not_have_permission(
notify_db_session,
permissions,
post_data,
):
service = create_service(service_permissions=permissions)
with pytest.raises(BadRequestError):
send_pdf_letter_notification(service.id, post_data)
def test_send_pdf_letter_notification_raises_error_if_service_is_over_daily_message_limit(
mocker,
sample_service_full_permissions,
post_data,
):
mocker.patch(
'app.service.send_notification.check_service_over_daily_message_limit',
side_effect=TooManyRequestsError(10))
with pytest.raises(TooManyRequestsError):
send_pdf_letter_notification(sample_service_full_permissions.id, post_data)
def test_send_pdf_letter_notification_validates_created_by(
sample_service_full_permissions,
sample_user,
post_data
):
post_data['created_by'] = sample_user.id
with pytest.raises(BadRequestError):
send_pdf_letter_notification(sample_service_full_permissions.id, post_data)
def test_send_pdf_letter_notification_raises_error_if_service_in_trial_mode(
mocker,
sample_service_full_permissions,
post_data,
):
sample_service_full_permissions.restricted = True
with pytest.raises(BadRequestError) as e:
send_pdf_letter_notification(sample_service_full_permissions.id, post_data)
assert 'trial mode' in e.value.message
@pytest.mark.skip(reason="Skipping letter-related functionality for now")
def test_send_pdf_letter_notification_raises_error_when_pdf_is_not_in_transient_letter_bucket(
mocker,
sample_service_full_permissions,
notify_user,
post_data,
):
mocker.patch('app.service.send_notification.utils_s3download', side_effect=S3ObjectNotFound({}, ''))
with pytest.raises(S3ObjectNotFound):
send_pdf_letter_notification(sample_service_full_permissions.id, post_data)
def test_send_pdf_letter_notification_does_nothing_if_notification_already_exists(
mocker,
sample_service_full_permissions,
notify_user,
sample_notification,
post_data,
):
post_data['file_id'] = sample_notification.id
mocker.patch('app.service.send_notification.utils_s3download', side_effect=S3ObjectNotFound({}, ''))
response = send_pdf_letter_notification(sample_service_full_permissions.id, post_data)
assert response['id'] == str(sample_notification.id)
@freeze_time("2019-08-02 11:00:00")
@pytest.mark.skip(reason="Skipping letter-related functionality for now")
def test_send_pdf_letter_notification_creates_notification_and_moves_letter(
mocker,
sample_service_full_permissions,
notify_user,
post_data,
):
mocker.patch('app.service.send_notification.utils_s3download')
mocker.patch('app.service.send_notification.get_page_count', return_value=1)
s3_mock = mocker.patch('app.service.send_notification.move_uploaded_pdf_to_letters_bucket')
result = send_pdf_letter_notification(sample_service_full_permissions.id, post_data)
file_id = post_data['file_id']
notification = get_notification_by_id(file_id)
assert str(notification.id) == file_id
assert notification.api_key_id is None
assert notification.client_reference == post_data['filename']
assert notification.created_by_id == post_data['created_by']
assert notification.postage == 'second'
assert notification.notification_type == LETTER_TYPE
assert notification.billable_units == 1
assert notification.to == "Bugs Bunny\n123 Main Street\nLooney Town"
assert notification.service_id == sample_service_full_permissions.id
assert result == {'id': str(notification.id)}
s3_mock.assert_called_once_with(
'service-{}/{}.pdf'.format(sample_service_full_permissions.id, file_id),
'2019-08-02/NOTIFY.{}.D.2.C.20190802110000.PDF'.format(notification.reference)
)

45
tests/app/service/test_rest.py
View File

@@ -2510,40 +2510,6 @@ def test_create_pdf_letter(mocker, sample_service_full_permissions, client, fake
assert json_resp == {'id': fake_uuid}
@pytest.mark.parametrize('post_data, expected_errors', [
(
{},
[
{'error': 'ValidationError', 'message': 'postage is a required property'},
{'error': 'ValidationError', 'message': 'filename is a required property'},
{'error': 'ValidationError', 'message': 'created_by is a required property'},
{'error': 'ValidationError', 'message': 'file_id is a required property'},
{'error': 'ValidationError', 'message': 'recipient_address is a required property'}
]
),
(
{"postage": "third", "filename": "string", "created_by": "string", "file_id": "string",
"recipient_address": "Some Address"},
[
{'error': 'ValidationError',
'message': 'postage invalid. It must be first, second, europe or rest-of-world.'}
]
)
])
def test_create_pdf_letter_validates_against_json_schema(
sample_service_full_permissions, client, post_data, expected_errors
):
response = client.post(
url_for('service.create_pdf_letter', service_id=sample_service_full_permissions.id),
data=json.dumps(post_data),
headers=[('Content-Type', 'application/json'), create_admin_authorization_header()]
)
json_resp = json.loads(response.get_data(as_text=True))
assert response.status_code == 400
assert json_resp['errors'] == expected_errors
def test_get_notification_for_service_includes_template_redacted(admin_request, sample_notification):
resp = admin_request.get(
'service.get_notification_for_service',
@@ -2555,17 +2521,6 @@ def test_get_notification_for_service_includes_template_redacted(admin_request,
assert resp['template']['redact_personalisation'] is False
def test_get_notification_for_service_includes_precompiled_letter(admin_request, sample_notification):
resp = admin_request.get(
'service.get_notification_for_service',
service_id=sample_notification.service_id,
notification_id=sample_notification.id
)
assert resp['id'] == str(sample_notification.id)
assert resp['template']['is_precompiled_letter'] is False
def test_get_all_notifications_for_service_includes_template_redacted(admin_request, sample_service):
normal_template = create_template(sample_service)

77
tests/app/template/test_rest.py
View File

@@ -115,35 +115,6 @@ def test_create_a_new_template_for_a_service_adds_folder_relationship(
assert template.folder == parent_folder
@pytest.mark.parametrize("template_type, expected_postage", [
(SMS_TYPE, None), (EMAIL_TYPE, None), (LETTER_TYPE, "second")
])
def test_create_a_new_template_for_a_service_adds_postage_for_letters_only(
client, sample_service, template_type, expected_postage
):
data = {
'name': 'my template',
'template_type': template_type,
'content': 'template <b>content</b>',
'service': str(sample_service.id),
'created_by': str(sample_service.users[0].id)
}
if template_type in [EMAIL_TYPE, LETTER_TYPE]:
data["subject"] = "Hi, I have good news"
data = json.dumps(data)
auth_header = create_admin_authorization_header()
response = client.post(
'/service/{}/template'.format(sample_service.id),
headers=[('Content-Type', 'application/json'), auth_header],
data=data
)
assert response.status_code == 201
template = Template.query.filter(Template.name == 'my template').first()
assert template.postage == expected_postage
def test_create_template_should_return_400_if_folder_is_for_a_different_service(
client, sample_service
):
@@ -323,8 +294,8 @@ def test_should_be_error_if_service_does_not_exist_on_update(client, fake_uuid):
assert json_resp['message'] == 'No result found'
@pytest.mark.parametrize('template_type', [EMAIL_TYPE, LETTER_TYPE])
def test_must_have_a_subject_on_an_email_or_letter_template(client, sample_user, sample_service, template_type):
@pytest.mark.parametrize('template_type', [EMAIL_TYPE])
def test_must_have_a_subject_on_an_email_template(client, sample_user, sample_service, template_type):
data = {
'name': 'my template',
'template_type': template_type,
@@ -429,50 +400,6 @@ def test_should_be_able_to_archive_template_should_remove_template_folders(
assert not updated_template.folder
def test_get_precompiled_template_for_service(
client,
notify_user,
sample_service,
):
assert len(sample_service.templates) == 0
response = client.get(
'/service/{}/template/precompiled'.format(sample_service.id),
headers=[create_admin_authorization_header()],
)
assert response.status_code == 200
assert len(sample_service.templates) == 1
data = json.loads(response.get_data(as_text=True))
assert data['name'] == 'Pre-compiled PDF'
assert data['hidden'] is True
def test_get_precompiled_template_for_service_when_service_has_existing_precompiled_template(
client,
notify_user,
sample_service,
):
create_template(
sample_service,
template_name='Exisiting precompiled template',
template_type=LETTER_TYPE,
hidden=True)
assert len(sample_service.templates) == 1
response = client.get(
'/service/{}/template/precompiled'.format(sample_service.id),
headers=[create_admin_authorization_header()],
)
assert response.status_code == 200
assert len(sample_service.templates) == 1
data = json.loads(response.get_data(as_text=True))
assert data['name'] == 'Exisiting precompiled template'
assert data['hidden'] is True
def test_should_be_able_to_get_all_templates_for_a_service(client, sample_user, sample_service):
data = {
'name': 'my template 1',