def your_details():
form = NameForm(data={
'first_name': session.get(FIRST_NAME),
'last_name': session.get(LAST_NAME),
})
if form.validate_on_submit():
session[FIRST_NAME] = form.first_name.data
session[LAST_NAME] = form.last_name.data
session.modified = True
app.logger.info("redirecting", {'location': routes.get_raw("yourdetails.details_dob")})
redirect_url = utils.ensure_safe_redirect_url(
request.args.get('next', routes.get_relative("yourdetails.details_dob")))
return redirect(redirect_url)
elif form.errors:
app.logger.info("submission contains errors")
flash(form.errors)
# if still not 'session' cookie at this point we assume cookies are
# disabled on user's web browser
if not request.cookies.get('session'):
return make_response(render_template('cookies-disabled.html'), 400)
response = make_response(render_template("your-details.html", form=form, routes=routes))
# get session id
if not request.cookies.get("session_id_nojs"):
session_id = get_session_id()
g.session_id_override = session_id
if session_id:
# set session_id cookie to expire after 59 minutes
response.set_cookie("session_id_nojs", value=session_id, max_age=60 * 59,
secure=app.config.get("SESSION_COOKIE_SECURE"), httponly=True)
return response
def test_confirmation_sender_redirects(self, user_details_mock,
set_preference_mock, _):
""" Test confirmation_sender redirects properly """
test_cases = (
#(result, expected_endpoint)
(False, routes.get_absolute("yourdetails.generic_error")),
(True, routes.get_absolute("yourdetails.store_preference_result")),
)
user_details_mock.return_value = None
for case in test_cases:
with self.subTest(case=case):
set_preference_mock.return_value, endpoint = case
headers = {
'Content-type': 'application/json',
'cookie': common.SESSION_ID
}
result = self.client.post(
routes.get_raw("yourdetails.confirmation_sender"),
headers=headers)
assert result.status_code == HTTPStatus.FOUND
self.assertIn(endpoint, result.headers['Location'])
def test_thank_you(self, user_details_mock, is_session_valid_mock):
"""Test correct text is displayed if user has opted_out"""
headers = {'Content-type': 'application/json', 'cookie': common.SESSION_ID}
userDetails = common.get_user_details()
test_cases = [
# (is_session_valid, opted_out, flask_session, expected_status, expected_text, expected_text_id, expected_location)
(True, 'active', {'is_successfully_stored': True}, HTTPStatus.OK, 'will not be used', 'not-shared', None),
(True, 'inactive', {'is_successfully_stored': True}, HTTPStatus.OK, 'can be used', 'shared', None),
(True, 'active', {'is_successfully_stored': False}, HTTPStatus.FOUND, None, None, routes.get_absolute('yourdetails.choice_not_saved')),
(True, 'inactive', {'is_successfully_stored': False}, HTTPStatus.FOUND, None, None, routes.get_absolute('yourdetails.choice_not_saved')),
(False, 'inactive', {}, HTTPStatus.OK, 'Sorry, you\'ll have to start again', 'mainBody', None),
(True, 'inactive', {}, HTTPStatus.OK, 'Sorry, you\'ll have to start again', 'mainBody', None),
]
for case in test_cases:
is_session_valid, opted_out, flask_session, expected_status, expected_text, \
expected_text_id, expected_location = case
with self.subTest(case=case):
userDetails["opted_out"] = opted_out
user_details_mock.return_value = userDetails
is_session_valid_mock.return_value = is_session_valid
common.set_session_data(self.client, flask_session)
result = self.client.get(routes.get_raw('yourdetails.thank_you'), headers=headers)
self.assertEqual(result.status_code, expected_status)
if expected_text:
doc = common.html(result)
self.assertIn(expected_text, str(doc.find(id=expected_text_id)))
if expected_location:
self.assertIn(expected_location, result.headers['Location'])
def test_waiting_for_results_redirecting_when_timeout(self,
check_status_of_pds_search_result_mock, redirect_mock, _):
""" Test waiting_for_results page redirect to error when timeout"""
common.registerExceptionHandlers(self.app)
redirect_mock.return_value = "_"
check_status_of_pds_search_result_mock.return_value = "pds_request_timeout"
self.client.get(routes.get_raw("verification.waiting_for_results"))
redirect_mock.assert_called_with("main.generic_error")
def test_rerender_waiting_for_results(self,
check_status_of_pds_search_result_mock, render_mock, _):
""" Test waiting_for_results rerender itself"""
render_mock.return_value = "_"
check_status_of_pds_search_result_mock.return_value = "incomplete"
self.client.get(routes.get_raw("verification.waiting_for_results"))
render_mock.assert_called_with('waiting-for-results.html',
waiting_message=constants.PDS_SEARCH_WAITING_MESSAGE, routes=routes)
def test_waiting_for_results_redirecting_on_timeout(self, redirect_mock, _):
""" Test waiting_for_results page redirect to genericerror on timeout"""
redirect_mock.return_value = "_"
with self.client as c:
with c.session_transaction() as session:
session['timeout_threshold'] = 1
self.client.get(routes.get_raw("verification.waiting_for_results"))
redirect_mock.assert_called_with("main.generic_error")
def your_details():
app.logger.info("starting controller",
{'controller': "yourdetails.your_details"})
form = NameForm()
if FIRST_NAME in session and LAST_NAME in session:
form.first_name.data = session[FIRST_NAME]
form.last_name.data = session[LAST_NAME]
if form.is_submitted():
form.first_name.data = request.form[FIRST_NAME]
form.last_name.data = request.form[LAST_NAME]
session[FIRST_NAME] = form.first_name.data
session[LAST_NAME] = form.last_name.data
if form.validate():
session.modified = True
app.logger.info(
"redirecting",
{'location': routes.get_raw("yourdetails.details_dob")})
redirect_url = utils.ensure_safe_redirect_url(
request.args.get(
'next', routes.get_relative("yourdetails.details_dob")))
return redirect(redirect_url)
elif form.errors:
app.logger.info("submission contains errors")
flash(form.errors)
#if still not 'session' cookie at this point we assume cookies are
#disabled on user's web browser
if not request.cookies.get('session'):
app.logger.info('rendering page', {'page': 'cookies-disabled.html'})
return make_response(render_template('cookies-disabled.html'), 400)
response = make_response(
render_template("your-details.html", form=form, routes=routes))
# get session id
if not request.cookies.get("session_id_nojs"):
session_id = get_session_id()
g.session_id_override = session_id
if session_id:
# set session_id cookie to expire after 59 minutes
response.set_cookie("session_id_nojs",
value=session_id,
max_age=60 * 59,
secure=True,
httponly=True)
app.logger.info('rendering page', {'page': 'your_details_name'})
return response
def test_waiting_for_results_redirecting_when_having_contact_details(self,
check_status_of_pds_search_result_mock, redirect_mock, _):
""" Test waiting_for_results page redirect to verificationoption when having contact details"""
redirect_mock.return_value = "_"
check_status_of_pds_search_result_mock.return_value = "success"
with self.client as c:
with c.session_transaction() as session:
session["sms"] = common.USER_DETAILS.get("sms")
session["email"] = common.USER_DETAILS.get("email")
self.client.get(routes.get_raw("verification.waiting_for_results"))
redirect_mock.assert_called_with("verification.verification_option")
def test_waiting_for_results_redirecting_when_no_contact_details(self,
check_status_of_pds_search_result_mock, redirect_mock, _):
""" Test waiting_for_results page redirect to contactdetailsnotfound when no contact details"""
redirect_mock.return_value = "_"
check_status_of_pds_search_result_mock.return_value = "insufficient_data"
self.client.get(routes.get_raw("verification.waiting_for_results"))
redirect_mock.assert_called_with("verification.contact_details_not_found")
with self.client as c:
with c.session_transaction() as session:
assert not session.get("email")
assert not session.get("sms")
def test_waiting_for_results_redirecting_when_search_fails(self,
check_status_of_pds_search_result_mock, redirect_mock, *_):
""" Test waiting_for_results page redirect to lookupfailureerror when pds search fails"""
redirect_mock.return_value = "_"
check_status_of_pds_search_result_mock.return_value = "invalid_user"
with self.client as c:
with c.session_transaction() as session:
session['timeout_threshold'] = constants.FAR_IN_THE_FUTURE
self.client.get(routes.get_raw("verification.waiting_for_results"))
redirect_mock.assert_called_with("verification.lookup_failure_error")
def test_review_your_choice_redirects_to_genericerror(
self, confirmation_delivery_mock, _, **kwargs):
confirmation_delivery_mock.return_value = None
mock = kwargs['mock']
adapter = mock.get(self.app.config['GET_CONFIRMATION_DELIVERY_METHOD'],
text=confirmation_delivery_method_callback)
user_details = common.get_user_details()
user_details['opted_out'] = 'active'
common.set_session_data(self.client, user_details)
result = self.client.get(
routes.get_raw('yourdetails.review_your_choice'))
assert HTTPStatus(result.status_code) == HTTPStatus.FOUND
assert routes.get_absolute(
'main.generic_error') == result.headers['Location']
def test_get_store_preference_result(self,
get_store_preference_result_mock, _):
""" Test store_preference_result redirects properly """
test_cases = (
#(store_ret, is_timeout_in_session, timeout_threshold, expected_status, expected_endpoint)
("success", False, 1, HTTPStatus.FOUND,
routes.get_absolute('main.generic_error')),
("success", False, constants.FAR_IN_THE_FUTURE, HTTPStatus.FOUND,
routes.get_absolute('yourdetails.thank_you')),
("not_completed", True, None, HTTPStatus.OK, None),
("failure", False, None, HTTPStatus.FOUND,
routes.get_absolute('yourdetails.choice_not_saved')),
)
for case in test_cases:
with self.subTest(case=case):
store_ret, is_timeout_in_session, timeout_threshold, status, endpoint = case
get_store_preference_result_mock.return_value = store_ret
common.update_session_data(
self.client, {'timeout_threshold': timeout_threshold})
headers = {
'Content-type': 'application/json',
'cookie': common.SESSION_ID
}
result = self.client.get(
routes.get_raw("yourdetails.store_preference_result"),
headers=headers)
self.assertEqual(result.status_code, status)
if status == HTTPStatus.FOUND:
self.assertIn(endpoint, result.headers['Location'])
self.assertEqual(
'timeout_threshold'
in common.get_session_data(self.client),
is_timeout_in_session)
def test_generic_error_renders_error_html(self, render_template_mock):
self.client.get(routes.get_raw('main.generic_error'))
render_template_mock.assert_called_with('error.html',
routes=unittest.mock.ANY)
def test_routes_get_raw_throws_exception(self):
with self.assertRaises(Exception) as context:
routes.get_raw('incorrect_route')
self.assertTrue('Invalid route' in str(context.exception))
from flask import Blueprint, redirect, render_template, request, make_response, session, current_app as app
from .forms import LandingPageForm
from ndopapp import utils
from ndopapp import routes
main_blueprint = Blueprint(
"main", __name__, template_folder="../templates/main")
@main_blueprint.route(routes.get_raw("main.root"), strict_slashes=False)
@utils.catch_unhandled_exceptions
def index():
app.logger.info("starting controller", {'controller': "main.index"})
app.logger.info("session cleared")
app.logger.info("redirecting", {'location': routes.get_absolute("main.landing_page")})
return redirect(routes.get_absolute("main.landing_page"))
@main_blueprint.route(routes.get_raw("main.landing_page"), methods=("GET", "POST"))
@utils.catch_unhandled_exceptions
def landingpage():
app.logger.info("starting controller", {'controller': "main.landing_page"})
form = LandingPageForm()
if request.method == "POST":
app.logger.info("redirecting", {'location': "yourdetails.your_details"})
resp = make_response(redirect(routes.get_absolute('yourdetails.your_details')))
return resp
app.logger.info('rendering page', {'page': 'landing_page'})
resp = make_response(render_template("landing-page.html", form=form, routes=routes, page="landing",
display_cookie_banner=request.cookies.get('ndop_seen_cookie_message')))
FIRST_NAME = "first_name"
LAST_NAME = "last_name"
DOB_DAY = "dob_day"
DOB_MONTH = "dob_month"
DOB_YEAR = "dob_year"
DOB = "dob"
DAY = "day"
MONTH = "month"
YEAR = "year"
NHS_NUMBER = "nhs_number"
POST_CODE = "postcode"
yourdetails_blueprint.add_url_rule(
routes.get_raw("yourdetails.choice_not_saved"),
view_func=TemplateView.as_view(
'choice_not_saved',
'choice-not-saved.html',
requires_session=False
)
)
yourdetails_blueprint.add_url_rule(
routes.get_raw("yourdetails.invalid_nhs_number"),
view_func=TemplateView.as_view(
'invalid_nhs_number',
'invalid-nhs-number.html',
requires_session=True
)
template_folder="../templates/yourdetails")
FIRST_NAME = "first_name"
LAST_NAME = "last_name"
DOB_DAY = "dob_day"
DOB_MONTH = "dob_month"
DOB_YEAR = "dob_year"
DOB = "dob"
DAY = "day"
MONTH = "month"
YEAR = "year"
NHS_NUMBER = "nhs_number"
POST_CODE = "postcode"
@yourdetails_blueprint.route(routes.get_raw("yourdetails.your_details"),
methods=("GET", "POST"))
@utils.catch_unhandled_exceptions
def your_details():
app.logger.info("starting controller",
{'controller': "yourdetails.your_details"})
form = NameForm()
if FIRST_NAME in session and LAST_NAME in session:
form.first_name.data = session[FIRST_NAME]
form.last_name.data = session[LAST_NAME]
if form.is_submitted():
form.first_name.data = request.form[FIRST_NAME]
form.last_name.data = request.form[LAST_NAME]
session[FIRST_NAME] = form.first_name.data
from flask import Blueprint, flash, render_template, session, current_app as app
from .forms import VerificationOption, CodeForm
from .models import is_otp_verified_by_pds, resend_code_by_pds, request_code_by_pds
from ndopapp import routes, constants, utils
from ndopapp.utils import TemplateView
from ndopapp.routes import redirect_to_route
from ndopapp.yourdetails.models import UserDetails
import json
verification_blueprint = Blueprint(
"verification", __name__, template_folder="../templates/verification"
)
verification_blueprint.add_url_rule(
routes.get_raw("verification.resend_code_error"),
view_func=TemplateView.as_view(
'resend_code_error',
'resend-code-error.html'
)
)
verification_blueprint.add_url_rule(
routes.get_raw("verification.contact_details_not_found"),
view_func=TemplateView.as_view(
'contact_details_not_found',
'contact-details-not-found.html'
)
)
verification_blueprint.add_url_rule(
from flask import Blueprint, render_template, request, make_response, session, current_app as app
from ndopapp.utils import TemplateView
from .forms import LandingPageForm
from ndopapp import routes
from ndopapp.routes import redirect_to_route
from ndopapp.csrf import csrf
main_blueprint = Blueprint("main",
__name__,
template_folder="../templates/main")
@main_blueprint.route(routes.get_raw("main.root"), strict_slashes=False)
def index():
return redirect_to_route("main.landing_page")
@main_blueprint.route(routes.get_raw("main.landing_page"),
methods=("GET", "POST"))
@csrf.exempt
def landing_page():
if request.method == "POST":
return make_response(redirect_to_route('yourdetails.your_details'))
session.clear()
app.logger.info("session cleared")
form = LandingPageForm()
resp = make_response(
render_template("landing-page.html",
form=form,
