mirror of
https://github.com/GSA/notifications-admin.git
synced 2026-07-02 15:38:19 -04:00
5fa115a8bd
(I suspect that) because Python dictionaries are not ordered, you can’t rely on the order of query parameters in a URL to match the arguments passed to `url_for`. This means the tests can intermittently fail. This does some hacky workaround stuff to still have reasonable test, but one that will pass whatever the order of the query parameters is.
495 lines
16 KiB
Python
495 lines
16 KiB
Python
from bs4 import BeautifulSoup, element
|
||
from functools import partial
|
||
import pytest
|
||
from flask import url_for
|
||
from werkzeug.exceptions import InternalServerError
|
||
from unittest.mock import Mock, ANY
|
||
from freezegun import freeze_time
|
||
from tests.conftest import (
|
||
mock_get_services,
|
||
mock_get_services_with_no_services,
|
||
mock_get_services_with_one_service
|
||
)
|
||
from app.main.views.feedback import has_live_services, in_business_hours
|
||
|
||
|
||
def no_redirect():
|
||
return lambda _external=True: None
|
||
|
||
|
||
def test_get_support_index_page(client):
|
||
resp = client.get(url_for('main.support'))
|
||
assert resp.status_code == 200
|
||
|
||
|
||
@freeze_time('2016-12-12 12:00:00.000000')
|
||
@pytest.mark.parametrize('support_type, expected_h1', [
|
||
('problem', 'Report a problem'),
|
||
('question', 'Ask a question or give feedback'),
|
||
])
|
||
@pytest.mark.parametrize('logged_in, expected_form_field, expected_contact_details', [
|
||
(True, type(None), 'We’ll reply to test@user.gov.uk'),
|
||
(False, element.Tag, None),
|
||
])
|
||
def test_choose_support_type(
|
||
client,
|
||
api_user_active,
|
||
mock_get_user,
|
||
mock_get_services,
|
||
logged_in,
|
||
expected_form_field,
|
||
expected_contact_details,
|
||
support_type,
|
||
expected_h1
|
||
):
|
||
if logged_in:
|
||
client.login(api_user_active)
|
||
response = client.post(
|
||
url_for('main.support'),
|
||
data={'support_type': support_type}, follow_redirects=True
|
||
)
|
||
assert response.status_code == 200
|
||
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
|
||
assert page.h1.string.strip() == expected_h1
|
||
assert isinstance(page.find('input', {'name': 'name'}), expected_form_field)
|
||
assert isinstance(page.find('input', {'name': 'email_address'}), expected_form_field)
|
||
if expected_contact_details:
|
||
assert page.find('form').find('p').text.strip() == expected_contact_details
|
||
|
||
|
||
@freeze_time('2016-12-12 12:00:00.000000')
|
||
@pytest.mark.parametrize('ticket_type, expected_status_code', [
|
||
('problem', 200),
|
||
('question', 200),
|
||
('gripe', 404)
|
||
])
|
||
def test_get_feedback_page(client, ticket_type, expected_status_code):
|
||
response = client.get(url_for('main.feedback', ticket_type=ticket_type))
|
||
assert response.status_code == expected_status_code
|
||
|
||
|
||
@freeze_time('2016-12-12 12:00:00.000000')
|
||
@pytest.mark.parametrize('ticket_type', ['problem', 'question'])
|
||
def test_passed_non_logged_in_user_details_through_flow(client, mocker, ticket_type):
|
||
mock_post = mocker.patch(
|
||
'app.main.views.feedback.requests.post',
|
||
return_value=Mock(status_code=201)
|
||
)
|
||
|
||
resp = client.post(
|
||
url_for('main.feedback', ticket_type=ticket_type),
|
||
data={'feedback': 'blah', 'name': 'Steve Irwin', 'email_address': 'rip@gmail.com'},
|
||
)
|
||
|
||
assert resp.status_code == 302
|
||
assert resp.location == url_for('main.thanks', urgent=True, anonymous=False, _external=True)
|
||
mock_post.assert_called_with(
|
||
ANY,
|
||
data={
|
||
'department_id': ANY,
|
||
'agent_team_id': ANY,
|
||
'subject': 'Notify feedback',
|
||
'message': 'Environment: http://localhost/\n\nblah',
|
||
'person_email': 'rip@gmail.com',
|
||
'person_name': 'Steve Irwin',
|
||
'label': ticket_type,
|
||
'urgency': ANY,
|
||
},
|
||
headers=ANY
|
||
)
|
||
|
||
|
||
@freeze_time("2016-12-12 12:00:00.000000")
|
||
@pytest.mark.parametrize('data', [
|
||
{'feedback': 'blah'},
|
||
{'feedback': 'blah', 'name': 'Ignored', 'email_address': 'ignored@email.com'}
|
||
])
|
||
@pytest.mark.parametrize('ticket_type', ['problem', 'question'])
|
||
def test_passes_user_details_through_flow(
|
||
logged_in_client,
|
||
mocker,
|
||
ticket_type,
|
||
data
|
||
):
|
||
mock_post = mocker.patch(
|
||
'app.main.views.feedback.requests.post',
|
||
return_value=Mock(status_code=201)
|
||
)
|
||
|
||
resp = logged_in_client.post(
|
||
url_for('main.feedback', ticket_type=ticket_type),
|
||
data=data,
|
||
)
|
||
|
||
assert resp.status_code == 302
|
||
assert resp.location == url_for('main.thanks', urgent=True, anonymous=False, _external=True)
|
||
mock_post.assert_called_with(
|
||
ANY,
|
||
data={
|
||
'department_id': ANY,
|
||
'agent_team_id': ANY,
|
||
'subject': 'Notify feedback',
|
||
'message': ANY,
|
||
'person_email': 'test@user.gov.uk',
|
||
'person_name': 'Test User',
|
||
'label': ticket_type,
|
||
'urgency': ANY,
|
||
},
|
||
headers=ANY
|
||
)
|
||
assert mock_post.call_args[1]['data']['message'] == '\n'.join([
|
||
'Environment: http://localhost/',
|
||
'Service "service one": {}'.format(url_for(
|
||
'main.service_dashboard',
|
||
service_id='596364a0-858e-42c8-9062-a8fe822260eb',
|
||
_external=True
|
||
)),
|
||
'',
|
||
'blah',
|
||
])
|
||
|
||
|
||
@freeze_time('2016-12-12 12:00:00.000000')
|
||
@pytest.mark.parametrize('data', [
|
||
{'feedback': 'blah', 'name': 'Fred'},
|
||
{'feedback': 'blah'},
|
||
])
|
||
@pytest.mark.parametrize('ticket_type, expected_response, things_expected_in_url, expected_error', [
|
||
('problem', 200, [], element.Tag),
|
||
('question', 302, ['thanks', 'anonymous=True', 'urgent=True'], type(None)),
|
||
])
|
||
def test_email_address_required_for_problems(
|
||
client,
|
||
mocker,
|
||
data,
|
||
ticket_type,
|
||
expected_response,
|
||
things_expected_in_url,
|
||
expected_error
|
||
):
|
||
mocker.patch(
|
||
'app.main.views.feedback.requests.post',
|
||
return_value=Mock(status_code=201)
|
||
)
|
||
response = client.post(
|
||
url_for('main.feedback', ticket_type=ticket_type),
|
||
data=data,
|
||
)
|
||
assert response.status_code == expected_response
|
||
# This is to work around non-deterministic query ordering in Flask url_for
|
||
for thing in things_expected_in_url:
|
||
assert thing in response.location
|
||
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
|
||
assert isinstance(page.find('span', {'class': 'error-message'}), expected_error)
|
||
|
||
|
||
@pytest.mark.parametrize('ticket_type, severe, is_in_business_hours, numeric_urgency, is_urgent', [
|
||
|
||
# business hours, always urgent
|
||
('problem', 'yes', True, 10, True),
|
||
('question', 'yes', True, 10, True),
|
||
('problem', 'no', True, 10, True),
|
||
('question', 'no', True, 10, True),
|
||
|
||
# out of hours, non emergency, never urgent
|
||
('problem', 'no', False, 1, False),
|
||
('question', 'no', False, 1, False),
|
||
|
||
# out of hours, emergency problems are urgent
|
||
('problem', 'yes', False, 10, True),
|
||
('question', 'yes', False, 1, False),
|
||
|
||
])
|
||
def test_urgency(
|
||
logged_in_client,
|
||
mocker,
|
||
ticket_type,
|
||
severe,
|
||
is_in_business_hours,
|
||
numeric_urgency,
|
||
is_urgent,
|
||
):
|
||
mocker.patch('app.main.views.feedback.in_business_hours', return_value=is_in_business_hours)
|
||
mock_post = mocker.patch('app.main.views.feedback.requests.post', return_value=Mock(status_code=201))
|
||
response = logged_in_client.post(
|
||
url_for('main.feedback', ticket_type=ticket_type, severe=severe),
|
||
data={'feedback': 'blah', 'email_address': 'test@example.com'},
|
||
)
|
||
assert response.status_code == 302
|
||
assert response.location == url_for('main.thanks', urgent=is_urgent, anonymous=False, _external=True)
|
||
assert mock_post.call_args[1]['data']['urgency'] == numeric_urgency
|
||
|
||
|
||
ids, params = zip(*[
|
||
('non-logged in users always have to triage', (
|
||
'problem', False, False, True,
|
||
302, partial(url_for, 'main.triage')
|
||
)),
|
||
('trial services are never high priority', (
|
||
'problem', False, True, False,
|
||
200, no_redirect()
|
||
)),
|
||
('we can triage in hours', (
|
||
'problem', True, True, True,
|
||
200, no_redirect()
|
||
)),
|
||
('only problems are high priority', (
|
||
'question', False, True, True,
|
||
200, no_redirect()
|
||
)),
|
||
('should triage out of hours', (
|
||
'problem', False, True, True,
|
||
302, partial(url_for, 'main.triage')
|
||
))
|
||
])
|
||
|
||
|
||
@pytest.mark.parametrize(
|
||
(
|
||
'ticket_type, is_in_business_hours, logged_in, has_live_services,'
|
||
'expected_status, expected_redirect'
|
||
),
|
||
params, ids=ids
|
||
)
|
||
def test_redirects_to_triage(
|
||
client,
|
||
api_user_active,
|
||
mocker,
|
||
mock_get_user,
|
||
ticket_type,
|
||
is_in_business_hours,
|
||
logged_in,
|
||
has_live_services,
|
||
expected_status,
|
||
expected_redirect,
|
||
):
|
||
mocker.patch('app.main.views.feedback.has_live_services', return_value=has_live_services)
|
||
mocker.patch('app.main.views.feedback.in_business_hours', return_value=is_in_business_hours)
|
||
if logged_in:
|
||
client.login(api_user_active)
|
||
|
||
response = client.get(url_for('main.feedback', ticket_type=ticket_type))
|
||
assert response.status_code == expected_status
|
||
assert response.location == expected_redirect(_external=True)
|
||
|
||
|
||
def test_doesnt_lose_message_if_post_across_closing(
|
||
logged_in_client,
|
||
mocker,
|
||
):
|
||
|
||
mocker.patch('app.main.views.feedback.has_live_services', return_value=True)
|
||
mocker.patch('app.main.views.feedback.in_business_hours', return_value=False)
|
||
|
||
response = logged_in_client.post(
|
||
url_for('main.feedback', ticket_type='problem'),
|
||
data={'feedback': 'foo'},
|
||
)
|
||
with logged_in_client.session_transaction() as session:
|
||
assert session['feedback_message'] == 'foo'
|
||
assert response.status_code == 302
|
||
assert response.location == url_for('.triage', _external=True)
|
||
|
||
response = logged_in_client.get(
|
||
url_for('main.feedback', ticket_type='problem', severe='yes')
|
||
)
|
||
assert response.status_code == 200
|
||
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
|
||
with logged_in_client.session_transaction() as session:
|
||
assert page.find('textarea', {'name': 'feedback'}).text == 'foo'
|
||
assert 'feedback_message' not in session
|
||
|
||
|
||
@pytest.mark.parametrize('get_services_mock, expected_return_value', [
|
||
(mock_get_services, True),
|
||
(mock_get_services_with_no_services, False),
|
||
(mock_get_services_with_one_service, False),
|
||
])
|
||
def test_has_live_services(
|
||
mocker,
|
||
fake_uuid,
|
||
get_services_mock,
|
||
expected_return_value
|
||
):
|
||
get_services_mock(mocker, fake_uuid)
|
||
assert has_live_services(12345) == expected_return_value
|
||
|
||
|
||
@pytest.mark.parametrize('when, is_in_business_hours', [
|
||
|
||
('2016-06-06 09:29:59+0100', False), # opening time, summer and winter
|
||
('2016-12-12 09:29:59+0000', False),
|
||
('2016-06-06 09:30:00+0100', True),
|
||
('2016-12-12 09:30:00+0000', True),
|
||
|
||
('2016-12-12 12:00:00+0000', True), # middle of the day
|
||
|
||
('2016-12-12 17:29:59+0000', True), # closing time
|
||
('2016-12-12 17:30:00+0000', False),
|
||
|
||
('2016-12-10 12:00:00+0000', False), # Saturday
|
||
('2016-12-11 12:00:00+0000', False), # Sunday
|
||
('2016-01-01 12:00:00+0000', False), # Bank holiday
|
||
|
||
])
|
||
def test_in_business_hours(when, is_in_business_hours):
|
||
with freeze_time(when):
|
||
assert in_business_hours() == is_in_business_hours
|
||
|
||
|
||
@pytest.mark.parametrize('choice, expected_redirect_param', [
|
||
('yes', True),
|
||
('no', False),
|
||
])
|
||
def test_triage_redirects_to_correct_url(client, choice, expected_redirect_param):
|
||
response = client.post(url_for('main.triage'), data={'severe': choice})
|
||
assert response.status_code == 302
|
||
assert response.location == url_for(
|
||
'main.feedback',
|
||
ticket_type='problem',
|
||
severe=expected_redirect_param,
|
||
_external=True,
|
||
)
|
||
|
||
|
||
@pytest.mark.parametrize(
|
||
(
|
||
'is_in_business_hours, severe,'
|
||
'expected_status_code, expected_redirect,'
|
||
'expected_status_code_when_logged_in, expected_redirect_when_logged_in'
|
||
),
|
||
[
|
||
(
|
||
True, 'yes',
|
||
200, no_redirect(),
|
||
200, no_redirect()
|
||
),
|
||
(
|
||
True, 'no',
|
||
200, no_redirect(),
|
||
200, no_redirect()
|
||
),
|
||
(
|
||
False, 'no',
|
||
200, no_redirect(),
|
||
200, no_redirect(),
|
||
),
|
||
|
||
# Treat empty query param as mangled URL – ask question again
|
||
(
|
||
False, '',
|
||
302, partial(url_for, 'main.triage'),
|
||
302, partial(url_for, 'main.triage'),
|
||
),
|
||
|
||
# User hasn’t answered the triage question
|
||
(
|
||
False, None,
|
||
302, partial(url_for, 'main.triage'),
|
||
302, partial(url_for, 'main.triage'),
|
||
),
|
||
|
||
# Escalation is needed for non-logged-in users
|
||
(
|
||
False, 'yes',
|
||
302, partial(url_for, 'main.bat_phone'),
|
||
200, no_redirect(),
|
||
),
|
||
]
|
||
)
|
||
def test_should_be_shown_the_bat_email(
|
||
client,
|
||
active_user_with_permissions,
|
||
mocker,
|
||
service_one,
|
||
mock_get_services,
|
||
is_in_business_hours,
|
||
severe,
|
||
expected_status_code,
|
||
expected_redirect,
|
||
expected_status_code_when_logged_in,
|
||
expected_redirect_when_logged_in,
|
||
):
|
||
|
||
mocker.patch('app.main.views.feedback.in_business_hours', return_value=is_in_business_hours)
|
||
|
||
feedback_page = url_for('main.feedback', ticket_type='problem', severe=severe)
|
||
|
||
response = client.get(feedback_page)
|
||
|
||
assert response.status_code == expected_status_code
|
||
assert response.location == expected_redirect(_external=True)
|
||
|
||
# logged in users should never be redirected to the bat email page
|
||
client.login(active_user_with_permissions, mocker, service_one)
|
||
logged_in_response = client.get(feedback_page)
|
||
assert logged_in_response.status_code == expected_status_code_when_logged_in
|
||
assert logged_in_response.location == expected_redirect_when_logged_in(_external=True)
|
||
|
||
|
||
def test_bat_email_page(
|
||
client,
|
||
active_user_with_permissions,
|
||
mocker,
|
||
service_one,
|
||
):
|
||
bat_phone_page = url_for('main.bat_phone')
|
||
|
||
response = client.get(bat_phone_page)
|
||
assert response.status_code == 200
|
||
|
||
client.login(active_user_with_permissions, mocker, service_one)
|
||
logged_in_response = client.get(bat_phone_page)
|
||
assert logged_in_response.status_code == 302
|
||
assert logged_in_response.location == url_for('main.feedback', ticket_type='problem', _external=True)
|
||
|
||
|
||
@freeze_time('2016-12-12 12:00:00.000000')
|
||
@pytest.mark.parametrize('ticket_type', ['problem', 'question'])
|
||
def test_log_error_on_post(app_, mocker, ticket_type):
|
||
mock_post = mocker.patch(
|
||
'app.main.views.feedback.requests.post',
|
||
return_value=Mock(
|
||
status_code=401,
|
||
json=lambda: {
|
||
'error_code': 'invalid_auth',
|
||
'error_message': 'Please provide a valid API key or token'}))
|
||
with app_.test_request_context():
|
||
mock_logger = mocker.patch.object(app_.logger, 'error')
|
||
with app_.test_client() as client:
|
||
with pytest.raises(InternalServerError):
|
||
client.post(
|
||
url_for('main.feedback', ticket_type=ticket_type),
|
||
data={'feedback': "blah", 'name': "Steve Irwin", 'email_address': 'rip@gmail.com'})
|
||
assert mock_post.called
|
||
mock_logger.assert_called_with(
|
||
"Deskpro create ticket request failed with {} '{}'".format(mock_post().status_code, mock_post().json()))
|
||
|
||
|
||
@pytest.mark.parametrize('logged_in', [True, False])
|
||
@pytest.mark.parametrize('urgent, anonymous, message', [
|
||
|
||
(True, False, 'We’ll get back to you within 30 minutes.'),
|
||
(False, False, 'We’ll get back to you by the next working day.'),
|
||
|
||
(True, True, 'We’ll look into it within 30 minutes.'),
|
||
(False, True, 'We’ll look into it by the next working day.'),
|
||
|
||
])
|
||
def test_thanks(
|
||
client,
|
||
mocker,
|
||
api_user_active,
|
||
mock_get_user,
|
||
urgent,
|
||
anonymous,
|
||
message,
|
||
logged_in,
|
||
):
|
||
if logged_in:
|
||
client.login(api_user_active)
|
||
response = client.get(url_for('main.thanks', urgent=urgent, anonymous=anonymous))
|
||
assert response.status_code == 200
|
||
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
|
||
assert ' '.join(page.find('main').find('p').text.split()) == message
|