darkhelm/notifications-admin
1
0
Fork 0
mirror of https://github.com/GSA/notifications-admin.git synced 2026-06-03 04:50:10 -04:00
Code Issues Packages Projects Releases Wiki Activity
Files
ec6bdee4274e5f49758ef98e8216a1bfc063f964
notifications-admin/tests/app/main/views/test_send.py
Carlo Costino 9a83ba7475 Localize notification_utils to the admin 
This changeset pulls in all of the notification_utils code directly into the admin and removes it as an external dependency. We are doing this to cut down on operational maintenance of the project and will begin removing parts of it no longer needed for the admin.

Signed-off-by: Carlo Costino <carlo.costino@gsa.gov>
2024-05-16 10:37:37 -04:00

3067 lines
84 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# -*- coding: utf-8 -*-
import uuid
from functools import partial
from glob import glob
from io import BytesIO
from itertools import repeat
from os import path
from random import randbytes
from uuid import uuid4
from zipfile import BadZipFile
import pytest
from flask import url_for
from notifications_python_client.errors import HTTPError
from xlrd.biffh import XLRDError
from xlrd.xldate import XLDateAmbiguous, XLDateError, XLDateNegative, XLDateTooLarge
from notifications_utils.recipients import RecipientCSV
from notifications_utils.template import SMSPreviewTemplate
from tests import validate_route_permission, validate_route_permission_with_client
from tests.conftest import (
SERVICE_ONE_ID,
create_active_caseworking_user,
create_active_user_with_permissions,
create_multiple_email_reply_to_addresses,
create_multiple_sms_senders,
create_template,
mock_get_service_email_template,
mock_get_service_template,
normalize_spaces,
)
FAKE_ONE_OFF_NOTIFICATION = {
"links": {},
"notifications": [
{
"api_key": None,
"billable_units": 0,
"carrier": None,
"client_reference": None,
"created_at": "2023-12-14T20:35:55+00:00",
"created_by": {
"email_address": "grsrbsrgsrf@fake.gov",
"id": "de059e0a-42e5-48bb-939e-4f76804ab739",
"name": "grsrbsrgsrf",
},
"document_download_count": None,
"id": "a3442b43-0ba1-4854-9e0a-d2fba1cc9b81",
"international": False,
"job": {
"id": "55b242b5-9f62-4271-aff7-039e9c320578",
"original_file_name": "1127b78e-a4a8-4b70-8f4f-9f4fbf03ece2.csv",
},
"job_row_number": 0,
"key_name": None,
"key_type": "normal",
"normalised_to": "+16615555555",
"notification_type": "sms",
"personalisation": {
"dayofweek": "2",
"favecolor": "3",
"phonenumber": "+16615555555",
},
"phone_prefix": "1",
"provider_response": None,
"rate_multiplier": 1.0,
"reference": None,
"reply_to_text": "development",
"sent_at": None,
"sent_by": None,
"service": "f62d840f-8bcb-4b36-b959-4687e16dd1a1",
"status": "created",
"template": {
"content": "((day of week)) and ((fave color))",
"id": "bd9caa7e-00ee-4c5a-839e-10ae1a7e6f73",
"name": "personalized",
"redact_personalisation": False,
"subject": None,
"template_type": "sms",
"version": 1,
},
"to": "+16615555555",
"updated_at": None,
}
],
"page_size": 50,
"total": 1,
}
template_types = ["email", "sms"]
unchanging_fake_uuid = uuid.uuid4()
# The * ignores hidden files, eg .DS_Store
test_spreadsheet_files = glob(path.join("tests", "spreadsheet_files", "*"))
test_non_spreadsheet_files = glob(path.join("tests", "non_spreadsheet_files", "*"))
def test_show_correct_title_and_description_for_email_sender_type(
client_request,
fake_uuid,
mock_get_service_email_template,
multiple_reply_to_email_addresses,
):
page = client_request.get(
".set_sender", service_id=SERVICE_ONE_ID, template_id=fake_uuid
)
assert (
page.select_one(".usa-fieldset h1").text.strip()
== "Where should replies come back to?"
)
def test_show_correct_title_and_description_for_sms_sender_type(
client_request,
fake_uuid,
mock_get_service_template,
multiple_sms_senders,
):
page = client_request.get(
".set_sender", service_id=SERVICE_ONE_ID, template_id=fake_uuid
)
assert (
page.select_one(".usa-fieldset h1").text.strip()
== "Who should the message come from?"
)
def test_default_email_sender_is_checked_and_has_hint(
client_request,
fake_uuid,
mock_get_service_email_template,
multiple_reply_to_email_addresses,
):
page = client_request.get(
".set_sender", service_id=SERVICE_ONE_ID, template_id=fake_uuid
)
assert page.select(".usa-radios input")[0].has_attr("checked")
assert (
normalize_spaces(page.select_one(".usa-radios .usa-hint").text) == "(Default)"
)
assert not page.select(".usa-radios input")[1].has_attr("checked")
def test_default_sms_sender_is_checked_and_has_hint(
client_request,
fake_uuid,
mock_get_service_template,
multiple_sms_senders_with_diff_default,
):
page = client_request.get(
".set_sender", service_id=SERVICE_ONE_ID, template_id=fake_uuid
)
assert page.select(".usa-radios input")[0].has_attr("checked")
assert (
normalize_spaces(page.select_one(".usa-radios .usa-hint").text) == "(Default)"
)
assert not page.select(".usa-radios input")[1].has_attr("checked")
def test_default_sms_sender_is_checked_and_has_hint_when_there_are_no_inbound_numbers(
client_request,
fake_uuid,
mock_get_service_template,
multiple_sms_senders_no_inbound,
):
page = client_request.get(
".set_sender", service_id=SERVICE_ONE_ID, template_id=fake_uuid
)
assert page.select(".usa-radios input")[0].has_attr("checked")
assert (
normalize_spaces(page.select_one(".usa-radios .usa-hint").text) == "(Default)"
)
assert not page.select(".usa-radios input")[1].has_attr("checked")
def test_default_inbound_sender_is_checked_and_has_hint_with_default_and_receives_text(
client_request,
service_one,
fake_uuid,
mock_get_service_template,
multiple_sms_senders,
):
page = client_request.get(
".set_sender", service_id=service_one["id"], template_id=fake_uuid
)
assert page.select(".usa-radios input")[0].has_attr("checked")
assert (
normalize_spaces(page.select_one(".usa-radios .usa-hint").text)
== "(Default and receives replies)"
)
assert not page.select(".usa-radios input")[1].has_attr("checked")
assert not page.select(".usa-radios input")[2].has_attr("checked")
def test_sms_sender_has_receives_replies_hint(
client_request,
service_one,
fake_uuid,
mock_get_service_template,
multiple_sms_senders,
):
page = client_request.get(
".set_sender", service_id=service_one["id"], template_id=fake_uuid
)
assert page.select(".usa-radios input")[0].has_attr("checked")
assert (
normalize_spaces(page.select_one(".usa-radios .usa-hint").text)
== "(Default and receives replies)"
)
assert not page.select(".usa-radios input")[1].has_attr("checked")
assert not page.select(".usa-radios input")[2].has_attr("checked")
@pytest.mark.parametrize(
("template_type", "sender_data"),
[
(
"email",
create_multiple_email_reply_to_addresses(),
),
("sms", create_multiple_sms_senders()),
],
)
def test_sender_session_is_present_after_selected(
client_request, service_one, fake_uuid, template_type, sender_data, mocker
):
template_data = create_template(template_type=template_type)
mocker.patch(
"app.service_api_client.get_service_template",
return_value={"data": template_data},
)
if template_type == "email":
mocker.patch(
"app.service_api_client.get_reply_to_email_addresses",
return_value=sender_data,
)
else:
mocker.patch("app.service_api_client.get_sms_senders", return_value=sender_data)
client_request.post(
".set_sender",
service_id=service_one["id"],
template_id=fake_uuid,
_data={"sender": "1234"},
)
with client_request.session_transaction() as session:
assert session["sender_id"] == "1234"
def test_set_sender_redirects_if_no_reply_to_email_addresses(
client_request,
fake_uuid,
mock_get_service_email_template,
no_reply_to_email_addresses,
):
client_request.get(
".set_sender",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
_expected_status=302,
_expected_url=url_for(
".send_one_off",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
),
)
def test_set_sender_redirects_if_no_sms_senders(
client_request,
fake_uuid,
mock_get_service_template,
no_sms_senders,
):
client_request.get(
".set_sender",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
_expected_status=302,
_expected_url=url_for(
".send_one_off",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
),
)
def test_set_sender_redirects_if_one_email_sender(
client_request,
fake_uuid,
mock_get_service_email_template,
single_reply_to_email_address,
):
client_request.get(
".set_sender",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
_expected_status=302,
_expected_url=url_for(
".send_one_off",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
),
)
with client_request.session_transaction() as session:
assert session["sender_id"] == "1234"
def test_set_sender_redirects_if_one_sms_sender(
client_request,
fake_uuid,
mock_get_service_template,
single_sms_sender,
):
client_request.get(
".set_sender",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
_expected_status=302,
_expected_url=url_for(
".send_one_off",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
),
)
with client_request.session_transaction() as session:
assert session["sender_id"] == "1234"
@pytest.mark.parametrize(
("sender_data"),
[
(create_multiple_sms_senders(isdefault1=True)),
],
)
def test_usnotify_and_notifygov_sms_sender_removal_not_default(sender_data, mocker):
from app.main.views.send import remove_notify_from_sender_options
sender_details = remove_notify_from_sender_options(sender_data)
assert len(sender_details) == 2
@pytest.mark.parametrize(
("sender_data"),
[
(create_multiple_sms_senders(isdefault1=False, isdefault3=True)),
(create_multiple_sms_senders(isdefault1=False, isdefault4=True)),
],
)
def test_usnotify_and_notifygov_sms_sender_removal_if_default(sender_data, mocker):
from app.main.views.send import remove_notify_from_sender_options
sender_details = remove_notify_from_sender_options(sender_data)
assert len(sender_details) == 3
def test_that_test_files_exist():
assert len(test_spreadsheet_files) == 8
assert len(test_non_spreadsheet_files) == 6
def test_should_not_allow_files_to_be_uploaded_without_the_correct_permission(
client_request,
mock_get_service_template,
service_one,
fake_uuid,
):
template_id = fake_uuid
service_one["permissions"] = []
page = client_request.get(
".send_messages",
service_id=SERVICE_ONE_ID,
template_id=template_id,
_follow_redirects=True,
_expected_status=403,
)
assert (
page.select("main p")[0].text.strip()
== "Sending text messages has been disabled for your service."
)
assert page.select(".usa-back-link")[0].text == "Back"
assert page.select(".usa-back-link")[0]["href"] == url_for(
".view_template",
service_id=service_one["id"],
template_id=template_id,
)
def test_example_spreadsheet(
client_request,
mock_get_service_template_with_placeholders_same_as_recipient,
fake_uuid,
):
page = client_request.get(
".send_messages", service_id=SERVICE_ONE_ID, template_id=fake_uuid
)
assert normalize_spaces(page.select_one("tbody tr").text) == (
"1 phone number name date"
)
assert page.select_one("input[type=file]").has_attr("accept")
assert (
page.select_one("input[type=file]")["accept"]
== ".csv,.xlsx,.xls,.ods,.xlsm,.tsv"
)
@pytest.mark.parametrize(
("filename", "acceptable_file", "expected_status"),
list(zip(test_spreadsheet_files, repeat(True), repeat(302)))
+ list(zip(test_non_spreadsheet_files, repeat(False), repeat(200))),
)
def test_upload_files_in_different_formats(
filename,
acceptable_file,
expected_status,
client_request,
service_one,
mocker,
mock_get_service_template,
mock_s3_set_metadata,
mock_s3_upload,
fake_uuid,
):
with open(filename, "rb") as uploaded:
page = client_request.post(
"main.send_messages",
service_id=service_one["id"],
template_id=fake_uuid,
_data={"file": (BytesIO(uploaded.read()), filename)},
_content_type="multipart/form-data",
_expected_status=expected_status,
)
if acceptable_file:
assert mock_s3_upload.call_args[0][1]["data"].strip() == (
"phone number,name,favourite colour,fruit\r\n"
"202 946 8050,Pete,Coral,tomato\r\n"
"202 712 5974,Not Pete,Magenta,Avacado\r\n"
"202 205 8823,Still Not Pete,Crimson,Pear"
)
mock_s3_set_metadata.assert_called_once_with(
SERVICE_ONE_ID, fake_uuid, original_file_name=filename
)
else:
assert not mock_s3_upload.called
assert normalize_spaces(page.select_one(".banner-dangerous").text) == (
"Could not read {}. Try using a different file format.".format(filename)
)
def test_send_messages_sanitises_and_truncates_file_name_for_metadata(
client_request,
service_one,
mocker,
mock_get_service_template_with_placeholders,
mock_s3_set_metadata,
mock_s3_get_metadata,
mock_s3_upload,
mock_s3_download,
mock_get_job_doesnt_exist,
fake_uuid,
):
filename = f"😁{'a' * 2000}.csv"
client_request.post(
"main.send_messages",
service_id=service_one["id"],
template_id=fake_uuid,
_data={"file": (BytesIO("".encode("utf-8")), filename)},
_content_type="multipart/form-data",
_follow_redirects=False,
)
assert len(mock_s3_set_metadata.call_args_list[0][1]["original_file_name"]) < len(
filename
)
assert mock_s3_set_metadata.call_args_list[0][1]["original_file_name"].startswith(
"?"
)
@pytest.mark.parametrize(
("exception", "expected_error_message"),
[
(
partial(UnicodeDecodeError, "codec", b"", 1, 2, "reason"),
("Could not read example.xlsx. Try using a different file format."),
),
(
BadZipFile,
("Could not read example.xlsx. Try using a different file format."),
),
(
XLRDError,
("Could not read example.xlsx. Try using a different file format."),
),
(
XLDateError,
(
"example.xlsx contains numbers or dates that Notify cannot understand. "
"Try formatting all columns as ‘text’ or export your file as CSV."
),
),
(
XLDateNegative,
(
"example.xlsx contains numbers or dates that Notify cannot understand. "
"Try formatting all columns as ‘text’ or export your file as CSV."
),
),
(
XLDateAmbiguous,
(
"example.xlsx contains numbers or dates that Notify cannot understand. "
"Try formatting all columns as ‘text’ or export your file as CSV."
),
),
(
XLDateTooLarge,
(
"example.xlsx contains numbers or dates that Notify cannot understand. "
"Try formatting all columns as ‘text’ or export your file as CSV."
),
),
],
)
def test_shows_error_if_parsing_exception(
client_request,
mocker,
mock_get_service_template,
exception,
expected_error_message,
fake_uuid,
):
def _raise_exception_or_partial_exception(file_content, filename):
raise exception()
mocker.patch(
"app.main.views.send.Spreadsheet.from_file",
side_effect=_raise_exception_or_partial_exception,
)
page = client_request.post(
"main.send_messages",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
_data={"file": (BytesIO(b"example"), "example.xlsx")},
_content_type="multipart/form-data",
_expected_status=200,
)
assert normalize_spaces(page.select_one(".banner-dangerous").text) == (
expected_error_message
)
def test_upload_csv_file_with_errors_shows_check_page_with_errors(
client_request,
service_one,
mocker,
mock_get_service_template_with_placeholders,
mock_s3_set_metadata,
mock_s3_get_metadata,
mock_s3_upload,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_get_jobs,
fake_uuid,
):
mocker.patch(
"app.main.views.send.s3download",
return_value="""
phone number,name
+12028675109
+12028675109
""",
)
page = client_request.post(
"main.send_messages",
service_id=service_one["id"],
template_id=fake_uuid,
_data={"file": (BytesIO("".encode("utf-8")), "example.csv")},
_content_type="multipart/form-data",
_follow_redirects=True,
)
with client_request.session_transaction() as session:
assert "file_uploads" not in session
assert page.select_one("input[type=file]").has_attr("accept")
assert (
page.select_one("input[type=file]")["accept"]
== ".csv,.xlsx,.xls,.ods,.xlsm,.tsv"
)
assert "There’s a problem with example.csv" in page.text
assert "+12028675109" in page.text
assert "Missing" in page.text
assert "Upload your file again" in page.text
def test_upload_csv_file_with_empty_message_shows_check_page_with_errors(
client_request,
service_one,
mocker,
mock_get_empty_service_template_with_optional_placeholder,
mock_s3_set_metadata,
mock_s3_get_metadata,
mock_s3_upload,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_get_jobs,
fake_uuid,
):
mocker.patch(
"app.main.views.send.s3download",
return_value="""
phone number, show_placeholder
+12028675109, yes
+12028675109, no
""",
)
page = client_request.post(
"main.send_messages",
service_id=service_one["id"],
template_id=fake_uuid,
_data={"file": (BytesIO("".encode("utf-8")), "example.csv")},
_content_type="multipart/form-data",
_follow_redirects=True,
)
with client_request.session_transaction() as session:
assert "file_uploads" not in session
assert normalize_spaces(page.select_one(".banner-dangerous").text) == (
"There’s a problem with example.csv "
"You need to check you have content for the empty message in 1 row."
)
assert [normalize_spaces(row.text) for row in page.select("tbody tr")] == [
"3 No content for this message",
"+12028675109 no",
]
assert normalize_spaces(page.select_one(".table-field-index").text) == "3"
assert page.select_one(".table-field-index")["rowspan"] == "2"
assert normalize_spaces(page.select("tbody tr td")[0].text) == "3"
assert normalize_spaces(page.select("tbody tr td")[1].text) == (
"No content for this message"
)
assert page.select("tbody tr td")[1]["colspan"] == "2"
def test_upload_csv_file_with_very_long_placeholder_shows_check_page_with_errors(
client_request,
service_one,
mocker,
mock_get_service_template_with_placeholders,
mock_s3_set_metadata,
mock_s3_get_metadata,
mock_s3_upload,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_get_jobs,
fake_uuid,
):
big_placeholder = " ".join(["not ok"] * 402)
mocker.patch(
"app.main.views.send.s3download",
return_value=f"""
phone number, name
+12028675109, {big_placeholder}
+12027700900, {big_placeholder}
""",
)
page = client_request.post(
"main.send_messages",
service_id=service_one["id"],
template_id=fake_uuid,
_data={"file": (BytesIO("".encode("utf-8")), "example.csv")},
_content_type="multipart/form-data",
_follow_redirects=True,
)
with client_request.session_transaction() as session:
assert "file_uploads" not in session
assert normalize_spaces(page.select_one(".banner-dangerous").text) == (
"There’s a problem with example.csv "
"You need to shorten the messages in 2 rows."
)
assert [normalize_spaces(row.text) for row in page.select("tbody tr")] == [
"2 Message is too long",
f"+12028675109 {big_placeholder}",
"3 Message is too long",
f"+12027700900 {big_placeholder}",
]
assert normalize_spaces(page.select_one(".table-field-index").text) == "2"
assert page.select_one(".table-field-index")["rowspan"] == "2"
assert normalize_spaces(page.select("tbody tr td")[0].text) == "2"
assert normalize_spaces(page.select("tbody tr td")[1].text) == (
"Message is too long"
)
assert page.select("tbody tr td")[1]["colspan"] == "2"
@pytest.mark.parametrize(
("file_contents", "expected_error"),
[
(
"""
telephone,name
+12028675109
""",
(
"There’s a problem with your column names "
"Your file needs a column called ‘phone number’. "
"Right now it has columns called ‘telephone’ and ‘name’."
),
),
(
"""
phone number
+12028675109
""",
(
"Your column names need to match the double brackets in your template "
"Your file is missing a column called ‘name’."
),
),
(
"""
phone number, phone number, PHONE_NUMBER
+12027900111,+12027900222,+12027900333,
""",
(
"There’s a problem with your column names "
"We found more than one column called ‘phone number’ or ‘PHONE_NUMBER’. "
"Delete or rename one of these columns and try again."
),
),
(
"""
phone number, name
""",
("Your file is missing some rows " "It needs at least one row of data."),
),
(
"+12028675109",
(
"Your file is missing some rows "
"It needs at least one row of data, and columns called ‘name’ and ‘phone number’."
),
),
(
"",
(
"Your file is missing some rows "
"It needs at least one row of data, and columns called ‘name’ and ‘phone number’."
),
),
(
"""
phone number, name
+12028675109, example
, example
+12028675109, example
""",
(
"There’s a problem with example.csv "
"You need to enter missing data in 1 row."
),
),
(
"""
phone number, name
+12028675109, example
+12028675109,
+12028675109, example
""",
(
"There’s a problem with example.csv "
"You need to enter missing data in 1 row."
),
),
],
)
def test_upload_csv_file_with_missing_columns_shows_error(
client_request,
mocker,
mock_get_service_template_with_placeholders,
mock_s3_set_metadata,
mock_s3_get_metadata,
mock_s3_upload,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_get_jobs,
service_one,
fake_uuid,
file_contents,
expected_error,
):
mocker.patch("app.main.views.send.s3download", return_value=file_contents)
page = client_request.post(
"main.send_messages",
service_id=service_one["id"],
template_id=fake_uuid,
_data={"file": (BytesIO("".encode("utf-8")), "example.csv")},
_follow_redirects=True,
)
with client_request.session_transaction() as session:
assert "file_uploads" not in session
assert page.select_one("input[type=file]").has_attr("accept")
assert (
page.select_one("input[type=file]")["accept"]
== ".csv,.xlsx,.xls,.ods,.xlsm,.tsv"
)
assert normalize_spaces(page.select(".banner-dangerous")[0].text) == expected_error
def test_upload_csv_invalid_extension(
client_request,
mock_login,
service_one,
mock_get_service_template,
fake_uuid,
):
page = client_request.post(
"main.send_messages",
service_id=service_one["id"],
template_id=fake_uuid,
_data={"file": (BytesIO("contents".encode("utf-8")), "invalid.txt")},
_content_type="multipart/form-data",
_follow_redirects=True,
)
assert "invalid.txt is not a spreadsheet that Notify can read" in page.text
def test_upload_csv_size_too_big(
client_request,
mock_login,
service_one,
mock_get_service_template,
fake_uuid,
):
page = client_request.post(
"main.send_messages",
service_id=service_one["id"],
template_id=fake_uuid,
_data={"file": (BytesIO(randbytes(11_000_000)), "invalid.csv")},
_content_type="multipart/form-data",
_follow_redirects=True,
)
assert "File must be smaller than 10Mb" in page.text
def test_upload_valid_csv_redirects_to_check_page(
client_request,
mock_get_service_template_with_placeholders,
mock_s3_upload,
mock_s3_set_metadata,
fake_uuid,
):
client_request.post(
"main.send_messages",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
_data={"file": (BytesIO("".encode("utf-8")), "valid.csv")},
_expected_status=302,
_expected_redirect=url_for(
"main.check_messages",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
upload_id=fake_uuid,
),
)
@pytest.mark.parametrize(
(
"extra_args",
"expected_link_in_first_row",
"expected_message",
),
[
(
{},
None,
"Test Service: A, Template <em>content</em> with & entity",
),
(
{"row_index": 2},
None,
"Test Service: A, Template <em>content</em> with & entity",
),
(
{"row_index": 4},
True,
"Test Service: C, Template <em>content</em> with & entity",
),
],
)
def test_upload_valid_csv_shows_preview_and_table(
client_request,
mocker,
mock_get_live_service,
mock_get_service_template_with_placeholders,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_get_jobs,
mock_s3_get_metadata,
mock_s3_set_metadata,
fake_uuid,
extra_args,
expected_link_in_first_row,
expected_message,
):
with client_request.session_transaction() as session:
session["file_uploads"] = {fake_uuid: {"template_id": fake_uuid}}
mocker.patch(
"app.main.views.send.s3download",
return_value="""
phone number,name,thing,thing,thing
2028675301, A, foo, foo, foo
2028675302, B, foo, foo, foo
2028675303, C, foo, foo,
""",
)
page = client_request.post(
"main.preview_job",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
upload_id=fake_uuid,
**extra_args,
_expected_status=200,
)
assert page.h1.text.strip() == "Preview"
assert page.select("h2")[1].text.strip() == "Recipients list"
assert page.h2.text.strip() == "Message"
assert page.select_one(".sms-message-wrapper").text.strip() == expected_message
assert not page.select_one(".table-field-index")
for row_index, row in enumerate(
[
(
'<td class="table-field-left-aligned"> <div> 2028675301 </div> </td>',
'<td class="table-field-left-aligned"> <div> A </div> </td>',
(
'<td class="table-field-left-aligned"> '
"<div> "
"<ul> "
"<li>foo</li> <li>foo</li> <li>foo</li> "
"</ul> "
"</div> "
"</td>"
),
),
(
'<td class="table-field-left-aligned"> <div> 2028675302 </div> </td>',
'<td class="table-field-left-aligned"> <div> B </div> </td>',
(
'<td class="table-field-left-aligned"> '
"<div> "
"<ul> "
"<li>foo</li> <li>foo</li> <li>foo</li> "
"</ul> "
"</div> "
"</td>"
),
),
(
'<td class="table-field-left-aligned"> <div> 2028675303 </div> </td>',
'<td class="table-field-left-aligned"> <div> C </div> </td>',
(
'<td class="table-field-left-aligned"> '
"<div> "
"<ul> "
"<li>foo</li> <li>foo</li> "
"</ul> "
"</div> "
"</td>"
),
),
]
):
for index, cell in enumerate(row):
row = page.select("table tbody tr")[row_index]
assert "id" not in row
assert normalize_spaces(str(row.select("td")[index])) == cell
def test_show_all_columns_if_there_are_duplicate_recipient_columns(
client_request,
mocker,
mock_get_live_service,
mock_get_service_template_with_placeholders,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_get_jobs,
fake_uuid,
mock_s3_get_metadata,
):
with client_request.session_transaction() as session:
session["file_uploads"] = {fake_uuid: {"template_id": fake_uuid}}
mocker.patch(
"app.main.views.send.s3download",
return_value="""
phone number, phone_number, PHONENUMBER
2028675301, 2028675302, 2028675303
""",
)
page = client_request.get(
"main.check_messages",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
upload_id=fake_uuid,
_test_page_title=False,
)
assert normalize_spaces(page.select_one("thead").text) == (
"Row in file1 phone number phone_number PHONENUMBER"
)
assert normalize_spaces(page.select_one("tbody").text) == (
"2 2028675303 2028675303 2028675303"
)
@pytest.mark.parametrize(
("row_index", "expected_status"),
[
(0, 404),
(1, 404),
(2, 200),
(3, 200),
(4, 200),
(5, 404),
],
)
def test_404_for_previewing_a_row_out_of_range(
client_request,
mocker,
mock_get_live_service,
mock_get_service_template_with_placeholders,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_get_jobs,
mock_s3_get_metadata,
mock_s3_set_metadata,
fake_uuid,
row_index,
expected_status,
):
with client_request.session_transaction() as session:
session["file_uploads"] = {fake_uuid: {"template_id": fake_uuid}}
mocker.patch(
"app.main.views.send.s3download",
return_value="""
phone number,name,thing,thing,thing
2028675301, A, foo, foo, foo
2028675302, B, foo, foo, foo
2028675303, C, foo, foo, foo
""",
)
client_request.get(
"main.check_messages",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
upload_id=fake_uuid,
row_index=row_index,
_expected_status=expected_status,
)
@pytest.mark.parametrize("template_type", ["sms", "email"])
def test_send_one_off_step_redirects_to_start_if_session_not_setup(
mocker,
client_request,
mock_get_service_statistics,
mock_get_users_by_service,
mock_has_no_jobs,
fake_uuid,
template_type,
):
template_data = create_template(template_type=template_type, content="Hi ((name))")
mocker.patch(
"app.service_api_client.get_service_template",
return_value={"data": template_data},
)
with client_request.session_transaction() as session:
assert "recipient" not in session
assert "placeholders" not in session
client_request.get(
"main.send_one_off_step",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
step_index=0,
_expected_status=302,
_expected_redirect=url_for(
"main.send_one_off",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
),
)
def test_send_one_off_does_not_send_without_the_correct_permissions(
client_request,
mock_get_service_template,
service_one,
fake_uuid,
):
template_id = fake_uuid
service_one["permissions"] = []
page = client_request.get(
".send_one_off",
service_id=SERVICE_ONE_ID,
template_id=template_id,
_follow_redirects=True,
_expected_status=403,
)
assert (
page.select("main p")[0].text.strip()
== "Sending text messages has been disabled for your service."
)
assert page.select(".usa-back-link")[0].text == "Back"
assert page.select(".usa-back-link")[0]["href"] == url_for(
".view_template",
service_id=service_one["id"],
template_id=template_id,
)
@pytest.mark.parametrize(
"user",
[
create_active_user_with_permissions(),
create_active_caseworking_user(),
],
)
def test_send_one_off_has_correct_page_title(
client_request,
service_one,
mock_has_no_jobs,
fake_uuid,
mocker,
user,
):
client_request.login(user)
template_data = create_template(
template_type="sms", name="Two week reminder", content="Hi there ((name))"
)
mocker.patch(
"app.service_api_client.get_service_template",
return_value={"data": template_data},
)
page = client_request.get(
"main.send_one_off",
service_id=service_one["id"],
template_id=fake_uuid,
step_index=0,
_follow_redirects=True,
)
assert page.h1.text.strip() == "Send ‘Two week reminder’"
assert len(page.select(".banner-tour")) == 0
@pytest.mark.parametrize(
("step_index", "prefilled", "expected_field_label"),
[
(
0,
{},
"phone number",
),
(
1,
{"phone number": "2020900123"},
"one",
),
(
2,
{"phone number": "2020900123", "one": "one"},
"two",
),
],
)
def test_send_one_off_shows_placeholders_in_correct_order(
client_request,
fake_uuid,
mock_has_no_jobs,
mock_get_service_template_with_multiple_placeholders,
step_index,
prefilled,
expected_field_label,
):
with client_request.session_transaction() as session:
session["recipient"] = None
session["placeholders"] = prefilled
page = client_request.get(
"main.send_one_off_step",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
step_index=step_index,
)
assert normalize_spaces(page.select_one("label").text) == expected_field_label
@pytest.mark.parametrize(
("user", "template_type", "expected_link_text", "expected_link_url"),
[
(
create_active_user_with_permissions(),
"sms",
"Use my phone number",
partial(url_for, "main.send_one_off_to_myself"),
),
(
create_active_user_with_permissions(),
"email",
"Use my email address",
partial(url_for, "main.send_one_off_to_myself"),
),
(create_active_caseworking_user(), "sms", None, None),
],
)
def test_send_one_off_has_skip_link(
client_request,
service_one,
fake_uuid,
mock_get_service_email_template,
mock_has_no_jobs,
mocker,
template_type,
expected_link_text,
expected_link_url,
user,
):
client_request.login(user)
template_data = create_template(template_id=fake_uuid, template_type=template_type)
mocker.patch(
"app.service_api_client.get_service_template",
return_value={"data": template_data},
)
page = client_request.get(
"main.send_one_off_step",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
step_index=0,
_follow_redirects=True,
)
skip_links = page.select("form a")
if expected_link_text and expected_link_url:
assert skip_links[1].text.strip() == expected_link_text
assert skip_links[1]["href"] == expected_link_url(
service_id=service_one["id"],
template_id=fake_uuid,
)
else:
with pytest.raises(IndexError):
skip_links[1]
@pytest.mark.parametrize(
("template_type", "expected_sticky"),
[
("sms", False),
("email", True),
],
)
def test_send_one_off_has_sticky_header_for_email(
mocker,
client_request,
fake_uuid,
mock_has_no_jobs,
template_type,
expected_sticky,
):
template_data = create_template(template_type=template_type, content="((body))")
mocker.patch(
"app.service_api_client.get_service_template",
return_value={"data": template_data},
)
page = client_request.get(
"main.send_one_off_step",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
step_index=0,
_follow_redirects=True,
)
assert bool(page.select(".js-stick-at-top-when-scrolling")) == expected_sticky
@pytest.mark.parametrize(
"user",
[
create_active_user_with_permissions(),
create_active_caseworking_user(),
],
)
def test_skip_link_will_not_show_on_sms_one_off_if_service_has_no_mobile_number(
client_request,
service_one,
fake_uuid,
mock_get_service_template,
mock_has_no_jobs,
mocker,
user,
):
user["mobile_number"] = None
client_request.login(user)
with client_request.session_transaction() as session:
session["recipient"] = None
session["placeholders"] = {}
page = client_request.get(
"main.send_one_off_step",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
step_index=0,
)
skip_link = page.findAll("a", text="Use my phone number")
assert not skip_link
@pytest.mark.parametrize(
"user",
[
create_active_user_with_permissions(),
create_active_caseworking_user(),
],
)
def test_send_one_off_offers_link_to_upload(
client_request,
fake_uuid,
mock_get_service_template,
mock_has_jobs,
user,
):
client_request.login(user)
page = client_request.get(
"main.send_one_off",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
_follow_redirects=True,
)
back_link = page.select_one(".usa-back-link")
link = page.select_one("form a")
assert back_link.text.strip() == "Back"
assert link.text.strip() == "Upload a list of phone numbers"
assert link["href"] == url_for(
"main.send_messages",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
)
def test_send_one_off_has_link_to_use_existing_list(
client_request,
mock_get_service_template,
mock_has_jobs,
fake_uuid,
):
page = client_request.get(
"main.send_one_off",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
_follow_redirects=True,
)
assert [(link.text, link["href"]) for link in page.select("form a")] == [
(
"Upload a list of phone numbers",
url_for(
"main.send_messages",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
),
),
(
"Use my phone number",
url_for(
"main.send_one_off_to_myself",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
),
),
]
@pytest.mark.parametrize(
"user",
[
create_active_user_with_permissions(),
create_active_caseworking_user(),
],
)
def test_link_to_upload_not_offered_when_entering_personalisation(
client_request,
fake_uuid,
mock_get_service_template_with_placeholders,
mock_has_jobs,
user,
):
client_request.login(user)
with client_request.session_transaction() as session:
session["recipient"] = "2029009009"
session["placeholders"] = {"phone number": "2029009009"}
page = client_request.get(
"main.send_one_off_step",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
step_index=1,
)
# We’re entering personalization
assert page.select_one("input[type=text]")["name"] == "placeholder_value"
assert page.select_one("label[for=placeholder_value]").text.strip() == "name"
# No ‘Upload’ link shown
assert len(page.select("main a")) == 0
assert "Upload" not in page.select_one("main").text
@pytest.mark.parametrize(
"user",
[
create_active_user_with_permissions(),
create_active_caseworking_user(),
],
)
def test_send_one_off_redirects_to_end_if_step_out_of_bounds(
client_request,
mock_has_no_jobs,
mock_get_service_template_with_placeholders,
fake_uuid,
mocker,
user,
):
client_request.login(user)
with client_request.session_transaction() as session:
session["recipient"] = "2020900123"
session["placeholders"] = {"name": "foo", "phone number": "2020900123"}
client_request.get(
"main.send_one_off_step",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
step_index=999,
_expected_status=302,
_expected_redirect=url_for(
"main.check_notification",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
),
)
@pytest.mark.parametrize(
"user",
[
create_active_user_with_permissions(),
create_active_caseworking_user(),
],
)
def test_send_one_off_redirects_to_start_if_you_skip_steps(
client_request,
service_one,
fake_uuid,
mock_s3_upload,
mock_get_users_by_service,
mock_get_service_statistics,
mock_has_no_jobs,
mocker,
user,
):
with client_request.session_transaction() as session:
session["placeholders"] = {"address_line_1": "foo"}
client_request.login(user)
client_request.get(
"main.send_one_off_step",
service_id=service_one["id"],
template_id=fake_uuid,
step_index=7,
_expected_redirect=url_for(
"main.send_one_off",
service_id=service_one["id"],
template_id=fake_uuid,
),
)
@pytest.mark.parametrize(
"user",
[
create_active_user_with_permissions(),
create_active_caseworking_user(),
],
)
def test_send_one_off_redirects_to_start_if_index_out_of_bounds_and_some_placeholders_empty(
client_request,
service_one,
fake_uuid,
mock_get_service_email_template,
mock_s3_download,
mock_get_users_by_service,
mock_get_service_statistics,
mock_has_no_jobs,
mocker,
user,
):
client_request.login(user)
with client_request.session_transaction() as session:
session["placeholders"] = {"name": "foo"}
client_request.get(
"main.send_one_off_step",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
step_index=999,
_expected_status=302,
_expected_redirect=url_for(
"main.send_one_off",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
),
)
@pytest.mark.parametrize(
"user",
[
create_active_user_with_permissions(),
create_active_caseworking_user(),
],
)
def test_send_one_off_sms_message_redirects(
client_request,
mocker,
service_one,
fake_uuid,
user,
):
client_request.login(user)
template = {"data": {"template_type": "sms", "folder": None}}
mocker.patch("app.service_api_client.get_service_template", return_value=template)
client_request.get(
"main.send_one_off",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
_expected_status=302,
_expected_response=url_for(
"main.send_one_off_step",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
step_index=0,
),
)
@pytest.mark.parametrize(
"user",
[
create_active_user_with_permissions(),
create_active_caseworking_user(),
],
)
def test_send_one_off_email_to_self_without_placeholders_redirects_to_check_page(
client_request,
mocker,
service_one,
mock_get_service_email_template_without_placeholders,
mock_s3_upload,
mock_get_users_by_service,
mock_get_service_statistics,
mock_has_no_jobs,
fake_uuid,
user,
):
client_request.login(user)
with client_request.session_transaction() as session:
session["recipient"] = "foo@bar.com"
session["placeholders"] = {"email address": "foo@bar.com"}
page = client_request.get(
"main.send_one_off_step",
step_index=1,
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
_follow_redirects=True,
)
assert page.select("h1")[0].text.strip() == "Select delivery time"
@pytest.mark.parametrize(
("permissions", "expected_back_link_endpoint", "extra_args"),
[
(
{"send_messages", "manage_templates"},
"main.view_template",
{"template_id": unchanging_fake_uuid},
),
(
{"send_messages"},
"main.choose_template",
{},
),
(
{"send_messages", "view_activity"},
"main.choose_template",
{},
),
],
)
def test_send_one_off_step_0_back_link(
client_request,
active_user_with_permissions,
mock_login,
mock_get_service,
mock_get_service_template_with_placeholders,
mock_has_no_jobs,
permissions,
expected_back_link_endpoint,
extra_args,
):
active_user_with_permissions["permissions"][SERVICE_ONE_ID] = permissions
client_request.login(active_user_with_permissions)
with client_request.session_transaction() as session:
session["placeholders"] = {}
session["recipient"] = None
page = client_request.get(
"main.send_one_off_step",
service_id=SERVICE_ONE_ID,
template_id=unchanging_fake_uuid,
step_index=0,
)
assert page.select(".usa-back-link")[0]["href"] == url_for(
expected_back_link_endpoint, service_id=SERVICE_ONE_ID, **extra_args
)
def test_send_one_off_sms_message_back_link_with_multiple_placeholders(
client_request,
mock_get_service_template_with_multiple_placeholders,
mock_has_no_jobs,
):
with client_request.session_transaction() as session:
session["recipient"] = "2020900123"
session["placeholders"] = {"phone number": "2020900123", "one": "bar"}
page = client_request.get(
"main.send_one_off_step",
service_id=SERVICE_ONE_ID,
template_id=unchanging_fake_uuid,
step_index=2,
)
assert page.select_one(".usa-back-link")["href"] == url_for(
"main.send_one_off_step",
service_id=SERVICE_ONE_ID,
template_id=unchanging_fake_uuid,
step_index=1,
)
def test_send_one_off_populates_field_from_session(
client_request,
mocker,
service_one,
mock_login,
mock_get_service,
mock_get_service_template_with_placeholders,
fake_uuid,
):
with client_request.session_transaction() as session:
session["recipient"] = None
session["placeholders"] = {}
session["placeholders"]["name"] = "Jo"
page = client_request.get(
"main.send_one_off_step",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
step_index=1,
)
assert page.select("input")[0]["value"] == "Jo"
def test_send_one_off_sms_message_puts_submitted_data_in_session(
client_request,
service_one,
mock_get_service_template_with_placeholders,
mock_get_users_by_service,
mock_get_service_statistics,
fake_uuid,
):
with client_request.session_transaction() as session:
session["recipient"] = "202-867-5303"
session["placeholders"] = {"phone number": "202-867-5303"}
client_request.post(
"main.send_one_off_step",
service_id=service_one["id"],
template_id=fake_uuid,
step_index=1,
_data={"placeholder_value": "Jo"},
_expected_status=302,
_expected_redirect=url_for(
"main.check_notification",
service_id=service_one["id"],
template_id=fake_uuid,
),
)
with client_request.session_transaction() as session:
assert session["recipient"] == "202-867-5303"
assert session["placeholders"] == {"phone number": "202-867-5303", "name": "Jo"}
def test_send_one_off_clears_session(
client_request,
mocker,
service_one,
fake_uuid,
):
template = {"data": {"template_type": "sms", "folder": None}}
mocker.patch("app.service_api_client.get_service_template", return_value=template)
with client_request.session_transaction() as session:
session["recipient"] = "2028675301"
session["placeholders"] = {"foo": "bar"}
client_request.get(
"main.send_one_off",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
_expected_status=302,
)
with client_request.session_transaction() as session:
assert session["recipient"] is None
assert session["placeholders"] == {}
def test_download_example_csv(
client_request,
mocker,
api_user_active,
mock_login,
mock_get_service,
mock_get_service_template_with_placeholders_same_as_recipient,
mock_has_permissions,
fake_uuid,
):
response = client_request.get_response(
"main.get_example_csv",
service_id=fake_uuid,
template_id=fake_uuid,
follow_redirects=True,
)
assert response.get_data(as_text=True) == (
"phone number,name,date\r\n" "12223334444,example,example\r\n"
)
assert "text/csv" in response.headers["Content-Type"]
def test_upload_csvfile_with_valid_phone_shows_all_numbers(
client_request,
mock_get_service_template,
mock_get_users_by_service,
mock_get_live_service,
mock_get_job_doesnt_exist,
mock_get_jobs,
mock_s3_get_metadata,
mock_s3_set_metadata,
service_one,
fake_uuid,
mock_s3_upload,
mocker,
):
mocker.patch(
"app.main.views.send.s3download",
return_value="\n".join(
["phone number"]
+ ["202 867 07{0:02d}".format(final_two) for final_two in range(0, 53)]
),
)
mock_get_notification_count = mocker.patch(
"app.service_api_client.get_notification_count", return_value=0
)
page = client_request.post(
"main.send_messages",
service_id=service_one["id"],
template_id=fake_uuid,
_data={"file": (BytesIO("".encode("utf-8")), "example.csv")},
_content_type="multipart/form-data",
_follow_redirects=True,
)
with client_request.session_transaction() as session:
assert "file_uploads" not in session
assert mock_s3_set_metadata.call_count == 2
assert mock_s3_set_metadata.call_args_list[0] == mocker.call(
SERVICE_ONE_ID, fake_uuid, original_file_name="example.csv"
)
assert mock_s3_set_metadata.call_args_list[1] == mocker.call(
SERVICE_ONE_ID,
fake_uuid,
notification_count=53,
template_id=fake_uuid,
valid=True,
original_file_name="example.csv",
)
assert "Select delivery time" in page.text
assert "202 867 0749" not in page.text
assert "202 867 0750" not in page.text
mock_get_notification_count.assert_called_with(service_one["id"])
@pytest.mark.parametrize(
("international_sms_permission", "should_allow_international"),
[
(False, False),
(True, True),
],
)
def test_upload_csvfile_with_international_validates(
mocker,
api_user_active,
client_request,
mock_get_service_template,
mock_s3_set_metadata,
mock_s3_get_metadata,
mock_s3_upload,
mock_has_permissions,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_get_jobs,
fake_uuid,
international_sms_permission,
should_allow_international,
service_one,
):
if international_sms_permission:
service_one["permissions"] += ("sms", "international_sms")
mocker.patch(
"app.service_api_client.get_service", return_value={"data": service_one}
)
mocker.patch("app.main.views.send.s3download", return_value="")
mock_recipients = mocker.patch(
"app.main.views.send.RecipientCSV",
return_value=RecipientCSV(
"", template=SMSPreviewTemplate({"content": "foo", "template_type": "sms"})
),
)
client_request.post(
"main.send_messages",
service_id=fake_uuid,
template_id=fake_uuid,
_data={"file": (BytesIO("".encode("utf-8")), "example.csv")},
_content_type="multipart/form-data",
_follow_redirects=True,
)
assert (
mock_recipients.call_args[1]["allow_international_sms"]
== should_allow_international
)
def test_test_message_can_only_be_sent_now(
client_request,
mocker,
service_one,
mock_get_service_template,
mock_s3_download,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_get_jobs,
mock_s3_get_metadata,
mock_s3_set_metadata,
fake_uuid,
):
content = client_request.get(
"main.check_messages",
service_id=service_one["id"],
upload_id=fake_uuid,
template_id=fake_uuid,
from_test=True,
)
assert 'name="scheduled_for"' not in content
def test_preview_button_is_correctly_labelled(
client_request,
mocker,
mock_get_live_service,
mock_get_service_template,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_get_jobs,
fake_uuid,
mock_s3_get_metadata,
):
mocker.patch(
"app.main.views.send.s3download",
return_value="\n".join(["phone_number"] + (["2028670123"] * 1000)),
)
mocker.patch("app.main.views.send.set_metadata_on_csv_upload")
page = client_request.get(
"main.check_messages",
service_id=SERVICE_ONE_ID,
upload_id=fake_uuid,
template_id=fake_uuid,
)
assert normalize_spaces(page.select_one("main [type=submit]").text) == ("Preview")
@pytest.mark.parametrize("when", ["", "2016-08-25T13:04:21.767198"])
def test_create_job_should_call_api(
client_request,
mock_create_job,
mock_get_job,
mock_get_notifications,
mock_get_service_template,
mock_get_service_data_retention,
mocker,
fake_uuid,
when,
):
data = mock_get_job(SERVICE_ONE_ID, fake_uuid)["data"]
job_id = data["id"]
original_file_name = data["original_file_name"]
template_id = data["template"]
notification_count = data["notification_count"]
with client_request.session_transaction() as session:
session["file_uploads"] = {
fake_uuid: {
"template_id": template_id,
"notification_count": notification_count,
"valid": True,
}
}
with client_request.session_transaction() as session:
session["scheduled_for"] = when
page = client_request.post(
"main.start_job",
service_id=SERVICE_ONE_ID,
upload_id=job_id,
original_file_name=original_file_name,
_data={
"scheduled_for": when,
},
_follow_redirects=True,
_expected_status=200,
)
assert "Message status" in page.text
mock_create_job.assert_called_with(
job_id,
SERVICE_ONE_ID,
scheduled_for=when,
)
@pytest.mark.parametrize(
("route", "response_code"),
[
("main.send_messages", 200),
("main.get_example_csv", 200),
("main.send_one_off", 302),
],
)
def test_route_permissions(
mocker,
notify_admin,
client_request,
api_user_active,
service_one,
mock_get_service_template,
mock_get_service_templates,
mock_get_jobs,
mock_get_notifications,
mock_create_job,
mock_s3_upload,
fake_uuid,
route,
response_code,
):
validate_route_permission(
mocker,
notify_admin,
"GET",
response_code,
url_for(route, service_id=service_one["id"], template_id=fake_uuid),
["view_activity", "send_messages"],
api_user_active,
service_one,
)
@pytest.mark.parametrize(
("route", "response_code", "method"),
[("main.check_notification", 200, "GET"), ("main.send_notification", 302, "POST")],
)
def test_route_permissions_send_check_notifications(
mocker,
notify_admin,
client_request,
api_user_active,
service_one,
mock_send_notification,
mock_get_service_template,
fake_uuid,
route,
response_code,
method,
mock_create_job,
mock_s3_upload,
):
with client_request.session_transaction() as session:
session["recipient"] = "2028675301"
session["placeholders"] = {"name": "a"}
mocker.patch("app.main.views.send.check_messages")
mocker.patch(
"app.notification_api_client.get_notifications_for_service",
return_value=FAKE_ONE_OFF_NOTIFICATION,
)
validate_route_permission_with_client(
mocker,
client_request,
method,
response_code,
url_for(route, service_id=service_one["id"], template_id=fake_uuid),
["send_messages"],
api_user_active,
service_one,
)
@pytest.mark.parametrize(
("route", "expected_status"),
[
("main.send_messages", 403),
("main.get_example_csv", 403),
("main.send_one_off", 403),
],
)
def test_route_permissions_sending(
mocker,
notify_admin,
client_request,
api_user_active,
service_one,
mock_get_service_template,
mock_get_service_templates,
mock_get_jobs,
mock_get_notifications,
mock_create_job,
fake_uuid,
route,
expected_status,
):
validate_route_permission(
mocker,
notify_admin,
"GET",
expected_status,
url_for(
route,
service_id=service_one["id"],
template_type="sms",
template_id=fake_uuid,
),
["blah"],
api_user_active,
service_one,
)
@pytest.mark.parametrize(
("template_type", "has_placeholders", "extra_args", "expected_url"),
[
("sms", False, dict(), partial(url_for, ".send_messages")),
("sms", True, dict(), partial(url_for, ".send_messages")),
("sms", True, dict(from_test=True), partial(url_for, ".send_one_off")),
],
)
def test_check_messages_back_link(
client_request,
mock_get_user_by_email,
mock_get_users_by_service,
mock_has_permissions,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_get_jobs,
mock_s3_download,
mock_s3_get_metadata,
mock_s3_set_metadata,
fake_uuid,
mocker,
template_type,
has_placeholders,
extra_args,
expected_url,
):
content = "Hi there ((name))" if has_placeholders else "Hi there"
template_data = create_template(
template_id=fake_uuid, template_type=template_type, content=content
)
mocker.patch(
"app.service_api_client.get_service_template",
return_value={"data": template_data},
)
with client_request.session_transaction() as session:
session["file_uploads"] = {
fake_uuid: {
"original_file_name": "valid.csv",
"template_id": fake_uuid,
"notification_count": 1,
"valid": True,
}
}
page = client_request.get(
"main.check_messages",
service_id=SERVICE_ONE_ID,
upload_id=fake_uuid,
template_id=fake_uuid,
_test_page_title=False,
**extra_args,
)
assert (page.find_all("a", {"class": "usa-back-link"})[0]["href"]) == expected_url(
service_id=SERVICE_ONE_ID, template_id=fake_uuid
)
@pytest.mark.parametrize(
("num_requested", "expected_msg"),
[
(None, "‘example.csv’ contains 1,234 phone numbers."),
("0", "‘example.csv’ contains 1,234 phone numbers."),
# This used to trigger the too many messages errors but we removed the daily limit
("1", "‘example.csv’ contains 1,234 phone numbers."),
],
ids=["none_sent", "none_sent", "some_sent"],
)
def test_check_messages_shows_too_many_messages_errors(
mocker,
client_request,
mock_get_service, # set message_limit to 50
mock_get_users_by_service,
mock_get_service_template,
mock_get_job_doesnt_exist,
mock_get_jobs,
fake_uuid,
num_requested,
expected_msg,
mock_s3_get_metadata,
):
# csv with 100 phone numbers
mocker.patch(
"app.main.views.send.s3download",
return_value=",\n".join(
["phone number"]
+ ([mock_get_users_by_service(None)[0]["mobile_number"]] * 1234)
),
)
mocker.patch("app.extensions.redis_client.get", return_value=num_requested)
with client_request.session_transaction() as session:
session["file_uploads"] = {
fake_uuid: {
"template_id": fake_uuid,
"notification_count": 1,
"valid": True,
}
}
page = client_request.get(
"main.check_messages",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
upload_id=fake_uuid,
_test_page_title=False,
)
assert page.find("h1").text.strip() == "Too many recipients"
assert (
page.find("div", class_="banner-dangerous").find("a").text.strip()
== "trial mode"
)
# remove excess whitespace from element
details = page.find("div", class_="banner-dangerous").find_all("p")[1]
details = " ".join(
[line.strip() for line in details.text.split("\n") if line.strip() != ""]
)
assert details == expected_msg
def test_check_messages_shows_trial_mode_error(
client_request,
mock_s3_get_metadata,
mock_get_users_by_service,
mock_get_service_template,
mock_has_permissions,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_get_jobs,
fake_uuid,
mocker,
):
mocker.patch(
"app.main.views.send.s3download",
return_value=("phone number,\n2028675209"), # Not in team
)
with client_request.session_transaction() as session:
session["file_uploads"] = {
fake_uuid: {
"template_id": "",
}
}
page = client_request.get(
"main.check_messages",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
upload_id=fake_uuid,
_test_page_title=False,
)
assert " ".join(page.find("div", class_="banner-dangerous").text.split()) == (
"You cannot send to this phone number "
"In trial mode you can only send to yourself and members of your team"
)
@pytest.mark.parametrize(
"uploaded_file_name",
[
pytest.param("applicants.ods"), # normal job
pytest.param("send_me_later.csv"), # should look at scheduled job
],
)
def test_warns_if_file_sent_already(
client_request,
mock_get_users_by_service,
mock_get_live_service,
mock_get_service_template,
mock_has_permissions,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_get_jobs,
fake_uuid,
mocker,
uploaded_file_name,
):
mocker.patch(
"app.main.views.send.s3download", return_value=("phone number,\n2028675209")
)
mocker.patch(
"app.main.views.send.get_csv_metadata",
return_value={"original_file_name": uploaded_file_name},
)
page = client_request.get(
"main.check_messages",
service_id=SERVICE_ONE_ID,
template_id="5d729fbd-239c-44ab-b498-75a985f3198f",
upload_id=fake_uuid,
original_file_name=uploaded_file_name,
_test_page_title=False,
)
assert normalize_spaces(page.select_one(".banner-dangerous").text) == (
"These messages have already been sent today "
"If you need to resend them, rename the file and upload it again."
)
mock_get_jobs.assert_called_once_with(SERVICE_ONE_ID, limit_days=0)
@pytest.mark.skip(reason="Test fails for unknown reason at this time.")
@pytest.mark.parametrize(
"uploaded_file_name",
[
pytest.param("thisisatest.csv"), # different template version
pytest.param("full_of_regret.csv"), # job is cancelled
],
)
def test_warns_if_file_sent_already_errors(
client_request,
mock_get_users_by_service,
mock_get_live_service,
mock_get_service_template,
mock_has_permissions,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_get_jobs,
fake_uuid,
mocker,
uploaded_file_name,
):
mocker.patch(
"app.main.views.send.s3download", return_value=("phone number,\n2028675209")
)
mocker.patch(
"app.main.views.send.get_csv_metadata",
return_value={"original_file_name": uploaded_file_name},
)
with pytest.raises(
expected_exception=Exception, match="Unable to locate credentials"
):
stmt_for_test_warns_if_file_sent_already_errors(
client_request, uploaded_file_name, fake_uuid, mock_get_jobs
)
def stmt_for_test_warns_if_file_sent_already_errors(
client_request, uploaded_file_name, fake_uuid, mock_get_jobs
):
page = client_request.get(
"main.check_messages",
service_id=SERVICE_ONE_ID,
template_id="5d729fbd-239c-44ab-b498-75a985f3198f",
upload_id=fake_uuid,
original_file_name=uploaded_file_name,
_test_page_title=False,
)
assert normalize_spaces(page.select_one(".banner-dangerous").text) == (
"These messages have already been sent today "
"If you need to resend them, rename the file and upload it again."
)
mock_get_jobs.assert_called_once_with(SERVICE_ONE_ID, limit_days=0)
def test_check_messages_column_error_doesnt_show_optional_columns(
mocker,
client_request,
mock_get_service_template,
mock_has_permissions,
fake_uuid,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_get_jobs,
mock_s3_get_metadata,
):
mocker.patch(
"app.main.views.send.s3download",
return_value="\n".join(
["address_line_1,address_line_2,foo"]
+ ["First Lastname,1 Example Road,SW1 1AA"]
),
)
with client_request.session_transaction() as session:
session["file_uploads"] = {
fake_uuid: {
"template_id": "",
"original_file_name": "",
}
}
page = client_request.get(
"main.check_messages",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
upload_id=fake_uuid,
_test_page_title=False,
)
assert normalize_spaces(page.select_one(".banner-dangerous").text) == (
"There’s a problem with your column names "
"Your file needs a column called ‘phone number’. "
"Right now it has columns called ‘address_line_1’, ‘address_line_2’ and ‘foo’."
)
def test_check_messages_adds_sender_id_in_session_to_metadata(
client_request,
mocker,
mock_get_live_service,
mock_get_service_template,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_get_jobs,
mock_s3_get_metadata,
mock_s3_set_metadata,
fake_uuid,
):
mocker.patch(
"app.main.views.send.s3download", return_value=("phone number,\n2028675209")
)
mocker.patch("app.main.views.send.get_sms_sender_from_session")
with client_request.session_transaction() as session:
session["file_uploads"] = {fake_uuid: {"template_id": fake_uuid}}
session["sender_id"] = "fake-sender"
client_request.get(
"main.check_messages",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
upload_id=fake_uuid,
_test_page_title=False,
)
mock_s3_set_metadata.assert_called_once_with(
SERVICE_ONE_ID,
fake_uuid,
notification_count=1,
template_id=fake_uuid,
sender_id="fake-sender",
valid=True,
original_file_name="example.csv",
)
def test_check_messages_shows_over_max_row_error(
client_request,
mock_get_users_by_service,
mock_get_service_template_with_placeholders,
mock_has_permissions,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_get_jobs,
mock_s3_get_metadata,
mock_s3_download,
fake_uuid,
mocker,
):
mock_recipients = mocker.patch("app.main.views.send.RecipientCSV").return_value
mock_recipients.max_rows = 11111
mock_recipients.__len__.return_value = 99999
mock_recipients.too_many_rows.return_value = True
with client_request.session_transaction() as session:
session["file_uploads"] = {
fake_uuid: {
"template_id": fake_uuid,
}
}
page = client_request.get(
"main.check_messages",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
upload_id=fake_uuid,
_test_page_title=False,
)
assert " ".join(page.find("div", class_="banner-dangerous").text.split()) == (
"Your file has too many rows "
"Notify can process up to 11,111 rows at once. "
"Your file has 99,999 rows."
)
@pytest.mark.parametrize(
"existing_session_items", [{}, {"recipient": "2028675301"}, {"name": "Jo"}]
)
def test_check_notification_redirects_if_session_not_populated(
client_request,
service_one,
fake_uuid,
existing_session_items,
mock_get_service_template_with_placeholders,
):
with client_request.session_transaction() as session:
session.update(existing_session_items)
client_request.get(
"main.check_notification",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
_expected_status=301,
_expected_redirect=url_for(
"main.send_one_off_step",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
step_index=1,
),
)
def test_check_notification_shows_scheduler(
client_request, service_one, fake_uuid, mock_get_service_template
):
with client_request.session_transaction() as session:
session["recipient"] = "2028675301"
session["placeholders"] = {}
page = client_request.get(
"main.check_notification", service_id=service_one["id"], template_id=fake_uuid
)
assert page.h1.text.strip() == "Select delivery time"
assert (page.find_all("a", {"class": "usa-back-link"})[0]["href"]) == url_for(
"main.send_one_off_step",
service_id=service_one["id"],
template_id=fake_uuid,
step_index=0,
)
# assert tour not visible
assert not page.select(".banner-tour")
# post to send_notification with help=0 to ensure no back link is then shown
assert page.form.attrs["action"] == url_for(
"main.preview_notification",
service_id=service_one["id"],
template_id=fake_uuid,
)
assert normalize_spaces(page.select_one("main [type=submit]").text) == ("Preview")
@pytest.mark.parametrize("when", ["", "2016-08-25T13:04:21.767198"])
def test_preview_notification_shows_preview(
client_request,
service_one,
fake_uuid,
mock_get_service_template,
when,
):
with client_request.session_transaction() as session:
session["recipient"] = "15555555555"
session["placeholders"] = {}
page = client_request.post(
"main.preview_notification",
service_id=service_one["id"],
template_id=fake_uuid,
_expected_status=200,
)
assert page.h1.text.strip() == "Preview"
assert (page.find_all("a", {"class": "usa-back-link"})[0]["href"]) == url_for(
"main.check_notification",
service_id=service_one["id"],
template_id=fake_uuid,
)
# assert tour not visible
assert not page.select(".banner-tour")
# post to send_notification with help=0 to ensure no back link is then shown
assert page.form.attrs["action"] == url_for(
"main.send_notification",
service_id=service_one["id"],
template_id=fake_uuid,
help="0",
)
@pytest.mark.parametrize(
("template", "recipient", "placeholders", "expected_personalisation"),
[
(
mock_get_service_template,
"2028675301",
{"a": "b"},
{"a": "b"},
),
(
mock_get_service_email_template,
"test@example.com",
{},
{},
),
],
)
def test_send_notification_submits_data(
client_request,
fake_uuid,
mock_get_service_template,
template,
recipient,
placeholders,
expected_personalisation,
mocker,
mock_create_job,
mock_s3_upload,
):
with client_request.session_transaction() as session:
session["recipient"] = recipient
session["placeholders"] = placeholders
mocker.patch(
"app.notification_api_client.get_notifications_for_service",
return_value=FAKE_ONE_OFF_NOTIFICATION,
)
mocker.patch("app.main.views.send.check_messages", return_value="")
client_request.post(
"main.send_notification", service_id=SERVICE_ONE_ID, template_id=fake_uuid
)
mock_create_job.assert_called_once()
def test_send_notification_clears_session(
client_request,
service_one,
fake_uuid,
mock_send_notification,
mock_get_service_template,
mocker,
mock_create_job,
mock_s3_upload,
):
with client_request.session_transaction() as session:
session["recipient"] = "2028675301"
session["placeholders"] = {"a": "b"}
mocker.patch("app.main.views.send.check_messages")
mocker.patch(
"app.notification_api_client.get_notifications_for_service",
return_value=FAKE_ONE_OFF_NOTIFICATION,
)
client_request.post(
"main.send_notification", service_id=service_one["id"], template_id=fake_uuid
)
with client_request.session_transaction() as session:
assert "recipient" not in session
assert "placeholders" not in session
@pytest.mark.parametrize(
"session_data",
[
{"placeholders": {"a": "b"}}, # missing recipient
{"recipient": "123"}, # missing placeholders
{"placeholders": {}, "recipient": ""}, # missing address
],
)
def test_send_notification_redirects_if_missing_data(
client_request,
fake_uuid,
session_data,
):
with client_request.session_transaction() as session:
session.update(session_data)
client_request.post(
"main.send_notification",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
_expected_status=302,
_expected_redirect=url_for(
".send_one_off",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
),
)
@pytest.mark.parametrize(
("extra_args", "extra_redirect_args"), [({}, {}), ({"help": "3"}, {"help": "3"})]
)
def test_send_notification_redirects_to_view_page(
client_request,
fake_uuid,
mock_send_notification,
mock_get_service_template,
extra_args,
extra_redirect_args,
mocker,
mock_create_job,
mock_s3_upload,
):
with client_request.session_transaction() as session:
session["recipient"] = "2028675301"
session["placeholders"] = {"a": "b"}
mocker.patch("app.main.views.send.check_messages")
mocker.patch(
"app.notification_api_client.get_notifications_for_service",
return_value=FAKE_ONE_OFF_NOTIFICATION,
)
client_request.post(
"main.send_notification",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
_expected_status=302,
**extra_args,
)
TRIAL_MODE_MSG = (
"Cannot send to this recipient when service is in trial mode – "
"see https://www.notifications.service.gov.uk/trial-mode"
)
TOO_LONG_MSG = "Text messages cannot be longer than 918 characters. Your message is 954 characters."
SERVICE_DAILY_LIMIT_MSG = "Exceeded send limits (1000) for today"
@pytest.mark.parametrize(
("exception_msg", "expected_h1", "expected_err_details"),
[
(
TRIAL_MODE_MSG,
"You cannot send to this phone number",
"In trial mode you can only send to yourself and members of your team",
),
(
TOO_LONG_MSG,
"Message too long",
"Text messages cannot be longer than 918 characters. Your message is 954 characters.",
),
(
SERVICE_DAILY_LIMIT_MSG,
"Daily limit reached",
"You can only send 1,000 messages per day in trial mode.",
),
],
)
def test_send_notification_shows_error_if_400(
client_request,
service_one,
fake_uuid,
mocker,
mock_get_service_template_with_placeholders,
mock_create_job,
exception_msg,
expected_h1,
expected_err_details,
mock_s3_upload,
):
class MockHTTPError(HTTPError):
message = exception_msg
mocker.patch(
"app.main.views.send.check_messages",
)
mocker.patch(
"app.notification_api_client.get_notifications_for_service",
return_value=FAKE_ONE_OFF_NOTIFICATION,
)
mocker.patch(
"app.notification_api_client.send_notification",
side_effect=MockHTTPError(),
)
with client_request.session_transaction() as session:
session["recipient"] = "2028675301"
session["placeholders"] = {"name": "a" * 900}
# This now redirects to the jobs results page
page = client_request.post(
"main.send_notification",
service_id=service_one["id"],
template_id=fake_uuid,
_expected_status=302,
)
assert not page.find("input[type=submit]")
def test_send_notification_shows_email_error_in_trial_mode(
client_request,
fake_uuid,
mocker,
mock_get_service_email_template,
mock_create_job,
mock_s3_upload,
):
class MockHTTPError(HTTPError):
message = TRIAL_MODE_MSG
status_code = 400
mocker.patch("app.main.views.send.check_messages")
mocker.patch(
"app.notification_api_client.get_notifications_for_service",
return_value=FAKE_ONE_OFF_NOTIFICATION,
)
mocker.patch(
"app.notification_api_client.send_notification",
side_effect=MockHTTPError(),
)
with client_request.session_transaction() as session:
session["recipient"] = "test@example.com"
session["placeholders"] = {"date": "foo", "thing": "bar"}
# Calling this means we successful ran a job so we will be redirect to the jobs page
client_request.post(
"main.send_notification",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
_expected_status=302,
)
@pytest.mark.parametrize(
("endpoint", "extra_args"),
[
("main.send_one_off_step", {"template_id": uuid4(), "step_index": 0}),
],
)
@pytest.mark.parametrize(
"reply_to_address",
[
None,
uuid4(),
],
)
def test_reply_to_is_previewed_if_chosen(
client_request,
mocker,
mock_get_service_email_template,
mock_s3_download,
mock_s3_get_metadata,
mock_s3_set_metadata,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_get_jobs,
get_default_reply_to_email_address,
fake_uuid,
endpoint,
extra_args,
reply_to_address,
):
mocker.patch(
"app.main.views.send.s3download",
return_value="""
email_address,date,thing
notify@digital.cabinet-office.gov.uk,foo,bar
""",
)
with client_request.session_transaction() as session:
session["recipient"] = "notify@digital.cabinet-office.gov.uk"
session["placeholders"] = {}
session["file_uploads"] = {fake_uuid: {"template_id": fake_uuid}}
session["sender_id"] = reply_to_address
page = client_request.get(endpoint, service_id=SERVICE_ONE_ID, **extra_args)
email_meta = page.select_one(".email-message-meta").text
if reply_to_address:
assert "test@example.com" in email_meta
else:
assert "test@example.com" not in email_meta
@pytest.mark.parametrize(
("endpoint", "extra_args"),
[
("main.check_messages", {"template_id": uuid4(), "upload_id": uuid4()}),
("main.send_one_off_step", {"template_id": uuid4(), "step_index": 0}),
],
)
@pytest.mark.parametrize(
"sms_sender",
[
None,
uuid4(),
],
)
def test_sms_sender_is_previewed(
client_request,
mocker,
mock_get_service_template,
mock_s3_download,
mock_s3_get_metadata,
mock_s3_set_metadata,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_get_jobs,
get_default_sms_sender,
fake_uuid,
endpoint,
extra_args,
sms_sender,
):
mocker.patch(
"app.main.views.send.s3download",
return_value="""
phone number,date,thing
2028675109,foo,bar
""",
)
with client_request.session_transaction() as session:
session["recipient"] = "2028675109"
session["placeholders"] = {}
session["file_uploads"] = {
fake_uuid: {
"template_id": fake_uuid,
"notification_count": 1,
"valid": True,
}
}
session["sender_id"] = sms_sender
page = client_request.get(endpoint, service_id=SERVICE_ONE_ID, **extra_args)
sms_sender_on_page = page.select_one(".sms-message-sender")
if sms_sender:
assert sms_sender_on_page.text.strip() == "From: GOVUK"
else:
assert not sms_sender_on_page
def test_redirects_to_template_if_job_exists_already(
client_request,
mock_get_service_email_template,
mock_get_job,
fake_uuid,
):
client_request.get(
"main.check_messages",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
upload_id=fake_uuid,
original_file_name="example.csv",
_expected_status=301,
_expected_redirect=url_for(
"main.send_messages",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
),
)
def test_send_to_myself_sets_placeholder_and_redirects_for_email(
mocker, client_request, fake_uuid, mock_get_service_email_template
):
with client_request.session_transaction() as session:
session["recipient"] = None
session["placeholders"] = {}
client_request.get(
"main.send_one_off_to_myself",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
_expected_status=302,
_expected_url=url_for(
"main.send_one_off_step",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
step_index=1,
),
)
with client_request.session_transaction() as session:
assert session["recipient"] == "test@user.gsa.gov"
assert session["placeholders"] == {"email address": "test@user.gsa.gov"}
def test_send_to_myself_sets_placeholder_and_redirects_for_sms(
mocker, client_request, fake_uuid, mock_get_service_template
):
with client_request.session_transaction() as session:
session["recipient"] = None
session["placeholders"] = {}
client_request.get(
"main.send_one_off_to_myself",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
_expected_status=302,
_expected_url=url_for(
"main.send_one_off_step",
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
step_index=1,
),
)
with client_request.session_transaction() as session:
assert session["recipient"] == "202-867-5303"
assert session["placeholders"] == {"phone number": "202-867-5303"}
Reference in New Issue View Git Blame Copy Permalink