def test_notification_page_shows_cancelled_or_failed_letter(
client_request,
mocker,
fake_uuid,
notification_status,
expected_message,
):
notification = create_notification(template_type='letter', notification_status=notification_status)
mocker.patch('app.notification_api_client.get_notification', return_value=notification)
mocker.patch(
'app.main.views.notifications.get_page_count_for_letter',
return_value=1,
)
page = client_request.get(
'main.view_notification',
service_id=SERVICE_ONE_ID,
notification_id=fake_uuid,
)
assert normalize_spaces(page.select('main p')[0].text) == (
"‘sample template’ was sent by Test User today at 1:01am"
)
assert normalize_spaces(page.select('main p')[1].text) == (
expected_message
)
assert not page.select('p.notification-status')
assert page.select_one('main img')['src'].endswith('.png?page=1')
def test_notification_page_shows_page_for_other_postage_classes(
client_request,
mocker,
fake_uuid,
postage,
expected_postage_text,
expected_class_value,
expected_delivery,
):
notification = create_notification(
notification_status='pending-virus-check',
template_type='letter',
postage=postage,
)
mocker.patch('app.notification_api_client.get_notification', return_value=notification)
mocker.patch('app.main.views.notifications.get_page_count_for_letter', return_value=3)
page = client_request.get(
'main.view_notification',
service_id=SERVICE_ONE_ID,
notification_id=fake_uuid,
)
assert normalize_spaces(page.select('main p:nth-of-type(2)')[0].text) == 'Printing starts tomorrow at 5:30pm'
assert normalize_spaces(page.select('main p:nth-of-type(3)')[0].text) == (
expected_delivery
)
assert normalize_spaces(page.select_one('.letter-postage').text) == (
expected_postage_text
)
assert page.select_one('.letter-postage')['class'] == [
'letter-postage', expected_class_value
]
def test_notification_page_has_expected_template_link_for_letter(
client_request, mocker, fake_uuid, service_one, is_precompiled_letter,
has_template_link):
if is_precompiled_letter:
mocker.patch('app.main.views.notifications.get_letter_file_data',
side_effect=[(b'foo', {
"message": "",
"invalid_pages": "[]",
"page_count": "1"
}), b'foo'])
mocker.patch('app.main.views.notifications.pdf_page_count', return_value=1)
notification = create_notification(
template_type='letter', is_precompiled_letter=is_precompiled_letter)
mocker.patch('app.notification_api_client.get_notification',
return_value=notification)
mocker.patch('app.main.views.notifications.get_page_count_for_letter',
return_value=1)
page = client_request.get(
'main.view_notification',
service_id=SERVICE_ONE_ID,
notification_id=fake_uuid,
)
link = page.select_one('main > p:nth-of-type(1) > a')
if has_template_link:
assert link
else:
assert link is None
def test_should_show_image_of_letter_notification_that_failed_validation(
logged_in_client,
fake_uuid,
mocker
):
notification = create_notification(template_type='letter', notification_status='validation-failed')
mocker.patch('app.notification_api_client.get_notification', return_value=notification)
metadata = {
'message': 'content-outside-printable-area',
'invalid_pages': '[1]',
'page_count': '1'
}
mocker.patch(
'app.main.views.notifications.notification_api_client.get_notification_letter_preview',
return_value={
'content': base64.b64encode(b'foo').decode('utf-8'),
'metadata': metadata
}
)
response = logged_in_client.get(url_for(
'main.view_letter_notification_as_preview',
service_id=SERVICE_ONE_ID,
notification_id=fake_uuid,
filetype='png',
with_metadata=True
))
assert response.status_code == 200
assert response.get_data(as_text=True) == 'foo', metadata
def test_notification_page_shows_page_for_first_class_letter_notification(
client_request,
mocker,
fake_uuid,
):
notification = create_notification(
notification_status='pending-virus-check',
template_type='letter',
postage='first')
mocker.patch('app.notification_api_client.get_notification',
return_value=notification)
mocker.patch('app.main.views.notifications.get_page_count_for_letter',
return_value=3)
page = client_request.get(
'main.view_notification',
service_id=SERVICE_ONE_ID,
notification_id=fake_uuid,
)
assert normalize_spaces(page.select('main p:nth-of-type(2)')
[0].text) == 'Printing starts tomorrow at 5:30pm'
assert normalize_spaces(page.select('main p:nth-of-type(3)')[0].text) == (
'Estimated delivery date: Tuesday 5 January')
assert normalize_spaces(
page.select_one('.letter-postage').text) == ('Postage: first class')
assert page.select_one('.letter-postage')['class'] == [
'letter-postage', 'letter-postage-first'
]
def test_notification_page_shows_error_message_if_precompiled_letter_cannot_be_opened(
client_request,
mocker,
fake_uuid,
):
notification = create_notification(
notification_status='validation-failed',
template_type='letter',
is_precompiled_letter=True)
mocker.patch('app.notification_api_client.get_notification', return_value=notification)
mocker.patch(
'app.main.views.notifications.get_letter_file_data',
side_effect=PdfReadError()
)
mocker.patch(
'app.main.views.notifications.pdf_page_count',
side_effect=PdfReadError()
)
page = client_request.get(
'main.view_notification',
service_id=SERVICE_ONE_ID,
notification_id=fake_uuid,
)
error_message = page.find('p', class_='notification-status-cancelled').text
assert normalize_spaces(error_message) == \
"Validation failed – There’s a problem with your letter. Notify cannot read this PDF."
def test_notification_status_page_shows_details(
client_request,
mocker,
mock_has_no_jobs,
service_one,
fake_uuid,
user,
key_type,
notification_status,
expected_status,
):
mocker.patch('app.user_api_client.get_user', return_value=user)
notification = create_notification(notification_status=notification_status,
key_type=key_type)
_mock_get_notification = mocker.patch(
'app.notification_api_client.get_notification',
return_value=notification)
page = client_request.get('main.view_notification',
service_id=service_one['id'],
notification_id=fake_uuid)
assert normalize_spaces(
page.select('.sms-message-recipient')[0].text) == ('To: 07123456789')
assert normalize_spaces(page.select('.sms-message-wrapper')[0].text) == (
'service one: hello Jo')
assert normalize_spaces(
page.select('.ajax-block-container p')[0].text) == (expected_status)
_mock_get_notification.assert_called_with(service_one['id'], fake_uuid)
def test_notification_status_page_respects_redaction(
client_request,
mocker,
service_one,
fake_uuid,
template_redaction_setting,
expected_content,
):
_mock_get_notification = mocker.patch(
'app.notification_api_client.get_notification',
return_value=create_notification(redact_personalisation=template_redaction_setting)
)
page = client_request.get(
'main.view_notification',
service_id=service_one['id'],
notification_id=fake_uuid
)
assert normalize_spaces(page.select('.sms-message-wrapper')[0].text) == expected_content
_mock_get_notification.assert_called_with(
service_one['id'],
fake_uuid,
)
def test_notification_page_has_link_to_download_letter(
client_request,
mocker,
fake_uuid,
service_one,
template_type,
expected_link,
):
notification = create_notification(template_type=template_type)
mocker.patch('app.notification_api_client.get_notification', return_value=notification)
mocker.patch(
'app.main.views.notifications.get_page_count_for_letter',
return_value=1
)
page = client_request.get(
'main.view_notification',
service_id=SERVICE_ONE_ID,
notification_id=fake_uuid,
)
try:
download_link = page.select_one('a[download]')['href']
except TypeError:
download_link = None
assert download_link == expected_link(notification_id=fake_uuid)
def test_read(
self,
student_user: User,
solution: Solution,
):
assert len(list(notifications.get(student_user))) == 0
message_id = conftest.create_notification(student_user, solution)
assert len(list(notifications.get(student_user))) == 1
unread = self.get_unread(student_user)
assert len(list(unread)) == 1
notifications.read(id_=message_id)
self.check_viewed_inbox(student_user)
# Test by notification ID
self.create_too_many_notifications(student_user, solution)
assert (len(list(
notifications.get(student_user))) == Notification.MAX_PER_USER)
for notification in notifications.get(student_user):
success = notifications.read(id_=notification.id)
assert success
self.check_full_inbox(student_user) # Still there
self.check_viewed_inbox(student_user) # But already viewed
# Test by user
self.create_too_many_notifications(student_user, solution)
assert (len(list(
notifications.get(student_user))) == Notification.MAX_PER_USER)
notifications.read(user=student_user)
self.check_full_inbox(student_user) # Still there
self.check_viewed_inbox(student_user) # But already viewed
def test_should_show_image_of_precompiled_letter_notification(
logged_in_client,
fake_uuid,
mocker,
):
notification = create_notification(template_type='letter', is_precompiled_letter=True)
mocker.patch('app.notification_api_client.get_notification', return_value=notification)
mock_pdf_page_count = mocker.patch(
'app.main.views.notifications.pdf_page_count',
return_value=1
)
mocker.patch(
'app.main.views.notifications.notification_api_client.get_notification_letter_preview',
return_value={
'content': base64.b64encode(b'foo').decode('utf-8')
}
)
response = logged_in_client.get(url_for(
'main.view_letter_notification_as_preview',
service_id=SERVICE_ONE_ID,
notification_id=fake_uuid,
filetype="png"
))
assert response.status_code == 200
assert response.get_data(as_text=True) == 'foo'
assert mock_pdf_page_count.called_once()
def test_notification_page_doesnt_link_to_template_in_tour(
mocker,
client_request,
fake_uuid,
mock_get_notification,
time_of_viewing_page,
expected_message,
):
with freeze_time('2012-01-01 01:01'):
notification = create_notification()
mocker.patch('app.notification_api_client.get_notification', return_value=notification)
with freeze_time(time_of_viewing_page):
page = client_request.get(
'main.view_notification',
service_id=SERVICE_ONE_ID,
notification_id=fake_uuid,
help=3,
)
assert normalize_spaces(page.select('main p:nth-of-type(1)')[0].text) == (
expected_message
)
assert len(page.select('main p:nth-of-type(1) a')) == 0
def test_notification_page_shows_page_for_letter_sent_with_test_key(
client_request,
mocker,
fake_uuid,
is_precompiled_letter,
expected_p1,
expected_p2,
expected_postage,
):
if is_precompiled_letter:
mocker.patch(
'app.main.views.notifications.get_letter_file_data',
return_value=(b'foo', {
'message': '',
'invalid_pages': '[]',
'page_count': '1'
})
)
mocker.patch(
'app.main.views.notifications.pdf_page_count',
return_value=1
)
mocker.patch(
'app.main.views.notifications.get_page_count_for_letter',
return_value=1,
)
notification = create_notification(
notification_status='created',
template_type='letter',
is_precompiled_letter=is_precompiled_letter,
postage='second',
key_type='test',
sent_one_off=False,
)
mocker.patch('app.notification_api_client.get_notification', return_value=notification)
page = client_request.get(
'main.view_notification',
service_id=SERVICE_ONE_ID,
notification_id=fake_uuid,
)
assert normalize_spaces(page.select('main p:nth-of-type(1)')[0].text) == (
expected_p1
)
assert normalize_spaces(page.select('main p:nth-of-type(2)')[0].text) == (
expected_p2
)
assert normalize_spaces(
page.select_one('.letter-postage').text
) == expected_postage
assert page.select('p.notification-status') == []
def test_notification_page_shows_page_for_letter_notification(
client_request,
mocker,
fake_uuid,
):
count_of_pages = 3
notification = create_notification(notification_status='created', template_type='letter', postage='second')
mocker.patch('app.notification_api_client.get_notification', return_value=notification)
mock_page_count = mocker.patch(
'app.main.views.notifications.get_page_count_for_letter',
return_value=count_of_pages
)
page = client_request.get(
'main.view_notification',
service_id=SERVICE_ONE_ID,
notification_id=fake_uuid,
)
assert normalize_spaces(page.select('main p:nth-of-type(1)')[0].text) == (
"‘sample template’ was sent by Test User today at 1:01am"
)
assert normalize_spaces(page.select('main p:nth-of-type(2)')[0].text) == (
'Printing starts today at 5:30pm'
)
assert normalize_spaces(page.select('main p:nth-of-type(3)')[0].text) == (
'Estimated delivery date: Wednesday 6 January'
)
assert len(page.select('.letter-postage')) == 1
assert normalize_spaces(page.select_one('.letter-postage').text) == (
'Postage: second class'
)
assert page.select_one('.letter-postage')['class'] == [
'letter-postage', 'letter-postage-second'
]
assert page.select('p.notification-status') == []
letter_images = page.select('main img')
assert len(letter_images) == count_of_pages
for index in range(count_of_pages):
image_src = page.select('img')[index]['src']
if "catalyst_logo.svg" in image_src:
continue
else:
assert page.select('img')[index]['src'].endswith('.png?page={}'.format(index))
assert len(mock_page_count.call_args_list) == 1
assert mock_page_count.call_args_list[0][0][0]['name'] == 'sample template'
assert mock_page_count.call_args_list[0][1]['values'] == {'name': 'Jo'}
def test_read_related(
self,
student_user: User,
solution: Solution,
exercise: Exercise,
):
solution2 = conftest.create_solution(student_user, exercise)
student_user2 = conftest.create_user(index=1)
messages = [
conftest.create_notification(student_user, solution),
conftest.create_notification(student_user, solution),
conftest.create_notification(student_user, solution),
conftest.create_notification(student_user, solution2),
conftest.create_notification(student_user2, solution),
]
assert all(not n.viewed for n in messages)
notifications.read_related(solution.id, student_user)
# peewee...
messages = [Notification.get_by_id(n.id) for n in messages]
assert all(n.viewed for n in messages[:3])
assert all(not n.viewed for n in messages[3:])
def test_get(
self,
student_user: User,
notification: Notification,
solution: Solution,
):
assert len(list(notifications.get(student_user))) == 1
n = next(iter(notifications.get(student_user)), None)
assert n is not None
assert n.user == student_user
assert n.related_id == solution.id
assert n.message == 'Test message 0'
student_user2 = conftest.create_student_user(index=1)
assert len(list(notifications.get(student_user2))) == 0
conftest.create_notification(student_user2, solution, index=2)
assert len(list(notifications.get(student_user))) == 1
assert len(list(notifications.get(student_user2))) == 1
self.create_too_many_notifications(student_user, solution)
assert (len(list(
notifications.get(student_user))) == Notification.MAX_PER_USER)
def test_should_show_reply_to_from_notification(
mocker,
fake_uuid,
notification_type,
client_request,
):
notification = create_notification(reply_to_text='reply to info', template_type=notification_type)
mocker.patch('app.notification_api_client.get_notification', return_value=notification)
page = client_request.get(
'main.view_notification',
service_id=SERVICE_ONE_ID,
notification_id=fake_uuid,
)
assert 'reply to info' in page.text
def test_notification_page_does_not_show_cancel_link_for_sms_or_email_notifications(
client_request,
mocker,
fake_uuid,
notification_type,
):
notification = create_notification(template_type=notification_type, notification_status='created')
mocker.patch('app.notification_api_client.get_notification', return_value=notification)
page = client_request.get(
'main.view_notification',
service_id=SERVICE_ONE_ID,
notification_id=fake_uuid,
)
assert 'Cancel sending this letter' not in normalize_spaces(page.text)
def test_notification_page_does_not_show_cancel_link_for_letter_which_cannot_be_cancelled(
client_request,
mocker,
fake_uuid,
):
notification = create_notification(template_type='letter')
mocker.patch('app.notification_api_client.get_notification',
return_value=notification)
mocker.patch('app.main.views.notifications.get_page_count_for_letter',
return_value=1)
page = client_request.get(
'main.view_notification',
service_id=SERVICE_ONE_ID,
notification_id=fake_uuid,
)
assert 'Cancel sending this letter' not in normalize_spaces(page.text)
def test_notification_page_shows_uploaded_letter(
client_request,
mocker,
fake_uuid,
):
mocker.patch(
'app.main.views.notifications.get_letter_file_data',
return_value=(b'foo', {
'message': '',
'invalid_pages': '[]',
'page_count': '1'
})
)
mocker.patch(
'app.main.views.notifications.pdf_page_count',
return_value=1
)
mocker.patch(
'app.main.views.notifications.get_page_count_for_letter',
return_value=1,
)
notification = create_notification(
notification_status='created',
template_type='letter',
is_precompiled_letter=True,
sent_one_off=True,
)
mocker.patch('app.notification_api_client.get_notification', return_value=notification)
page = client_request.get(
'main.view_notification',
service_id=SERVICE_ONE_ID,
notification_id=fake_uuid,
)
assert normalize_spaces(page.select('main p:nth-of-type(1)')[0].text) == (
'Uploaded by Test User yesterday at midnight'
)
assert normalize_spaces(page.select('main p:nth-of-type(2)')[0].text) == (
'Printing starts today at 5:30pm'
)
def test_show_cancel_letter_confirmation(
client_request,
mocker,
fake_uuid,
):
notification = create_notification(template_type='letter', notification_status='created')
mocker.patch('app.notification_api_client.get_notification', return_value=notification)
mocker.patch(
'app.main.views.notifications.get_page_count_for_letter',
return_value=1
)
page = client_request.get(
'main.cancel_letter',
service_id=SERVICE_ONE_ID,
notification_id=fake_uuid,
)
flash_message = normalize_spaces(page.find('div', class_='banner-dangerous').text)
assert 'Are you sure you want to cancel sending this letter?' in flash_message
def test_notification_status_page_formats_email_and_sms_status_correctly(
client_request,
mocker,
mock_has_no_jobs,
service_one,
fake_uuid,
active_user_with_permissions,
notification_type,
notification_status,
expected_class,
):
mocker.patch('app.user_api_client.get_user', return_value=active_user_with_permissions)
notification = create_notification(notification_status=notification_status, template_type=notification_type)
mocker.patch('app.notification_api_client.get_notification', return_value=notification)
page = client_request.get(
'main.view_notification',
service_id=service_one['id'],
notification_id=fake_uuid
)
assert page.select_one(f'.ajax-block-container p.notification-status.{expected_class}')
def test_notification_page_has_link_to_send_another_for_sms(
client_request,
mocker,
fake_uuid,
service_one,
service_permissions,
template_type,
link_expected,
):
service_one['permissions'] = service_permissions
notification = create_notification(template_type=template_type)
mocker.patch('app.notification_api_client.get_notification', return_value=notification)
mocker.patch(
'app.main.views.notifications.get_page_count_for_letter',
return_value=1
)
page = client_request.get(
'main.view_notification',
service_id=SERVICE_ONE_ID,
notification_id=fake_uuid,
)
last_paragraph = page.select('main p')[-1]
conversation_link = url_for(
'.conversation',
service_id=SERVICE_ONE_ID,
notification_id=fake_uuid,
_anchor='n{}'.format(fake_uuid),
)
if link_expected:
assert normalize_spaces(last_paragraph.text) == (
'See all text messages sent to this phone number'
)
assert last_paragraph.select_one('a')['href'] == conversation_link
else:
assert conversation_link not in str(page.select_one('main'))
def test_notification_page_shows_validation_failed_precompiled_letter(
client_request,
mocker,
fake_uuid,
):
notification = create_notification(template_type='letter',
notification_status='validation-failed',
is_precompiled_letter=True)
mocker.patch('app.notification_api_client.get_notification',
return_value=notification)
metadata = {
"page_count": "1",
"status": "validation-failed",
"invalid_pages": "[1]",
"message": "content-outside-printable-area"
}
mocker.patch('app.main.views.notifications.get_letter_file_data',
return_value=("some letter content", metadata))
mocker.patch(
'app.main.views.notifications.get_page_count_for_letter',
return_value=1,
)
page = client_request.get(
'main.view_notification',
service_id=SERVICE_ONE_ID,
notification_id=fake_uuid,
)
error_message = page.find('p', class_='notification-status-cancelled').text
assert normalize_spaces(error_message) == (
'Validation failed because content is outside the printable area on page 1.'
'Files must meet our letter specification.')
assert not page.select('p.notification-status')
assert page.select_one('main img')['src'].endswith('.png?page=1')
assert not page.select('.letter-postage')
def test_should_show_preview_error_image_letter_notification_on_preview_error(
logged_in_client,
fake_uuid,
mocker,
):
notification = create_notification(template_type='letter')
mocker.patch('app.notification_api_client.get_notification',
return_value=notification)
mocker.patch(
'app.main.views.notifications.notification_api_client.get_notification_letter_preview',
side_effect=APIError)
mocker.patch("builtins.open", mock_open(read_data=b"preview error image"))
response = logged_in_client.get(
url_for('main.view_letter_notification_as_preview',
service_id=SERVICE_ONE_ID,
notification_id=fake_uuid,
filetype='png'))
assert response.status_code == 200
assert response.get_data(as_text=True) == 'preview error image'
def test_cancelling_a_letter_calls_the_api(
client_request,
mocker,
fake_uuid,
):
notification = create_notification(template_type='letter', notification_status='created')
mocker.patch('app.notification_api_client.get_notification', return_value=notification)
mocker.patch(
'app.main.views.notifications.get_page_count_for_letter',
return_value=1
)
cancel_endpoint = mocker.patch(
'app.main.views.notifications.notification_api_client.update_notification_to_cancelled'
)
client_request.post(
'main.cancel_letter',
service_id=SERVICE_ONE_ID,
notification_id=fake_uuid,
_follow_redirects=True,
_expected_redirect=None,
)
assert cancel_endpoint.called
def create_too_many_notifications(user: User, solut: Solution):
for i in range(Notification.MAX_PER_USER + 5):
conftest.create_notification(user, solut, index=i)