Ensure CheckNeedAppointment requires DOB to be answered

Author: Themitchell

lung_cancer_screening/questions/tests/unit/views/test_check_need_appointment.py

@@ -2,16 +2,18 @@
 from django.urls import reverse
 
 from .helpers.authentication import login_user
-from lung_cancer_screening.questions.models.check_need_appointment_response import CheckNeedAppointmentResponse
 from ...factories.response_set_factory import ResponseSetFactory
+from ...factories.date_of_birth_response_factory import DateOfBirthResponseFactory
 
 @tag("CheckNeedAppointment")
 class TestGetCheckNeedAppointment(TestCase):
     def setUp(self):
         self.user = login_user(self.client)
 
+        self.response_set = ResponseSetFactory.create(user=self.user)
 
-    def test_get_redirects_if_the_user_is_not_logged_in(self):
+
+    def test_redirects_if_the_user_is_not_logged_in(self):
         self.client.logout()
 
         response = self.client.get(
@@ -21,7 +23,8 @@ def test_get_redirects_if_the_user_is_not_logged_in(self):
         self.assertRedirects(response, "/oidc/authenticate/?next=/check-if-you-need-an-appointment", fetch_redirect_response=False)
 
 
-    def test_get_redirects_when_an_submitted_response_set_exists_within_the_last_year(self):
+    def test_redirects_when_an_submitted_response_set_exists_within_the_last_year(self):
+        self.response_set.delete()
         ResponseSetFactory.create(
             user=self.user,
             recently_submitted=True
@@ -34,26 +37,43 @@ def test_get_redirects_when_an_submitted_response_set_exists_within_the_last_yea
         self.assertRedirects(response, reverse("questions:confirmation"))
 
 
-    def test_get_responds_successfully(self):
+    def test_redirects_if_hasnt_answered_date_of_birth(self):
         response = self.client.get(reverse("questions:check_need_appointment"))
 
-        self.assertEqual(response.status_code, 200)
+        self.assertRedirects(response, reverse("questions:date_of_birth"), fetch_redirect_response=False)
+
 
+    def test_redirects_if_has_answered_date_of_birth_with_ineligible_response(self):
+        DateOfBirthResponseFactory.create(
+            response_set=self.response_set,
+            ineligible=True
+        )
 
-    def test_get_contains_the_correct_form_fields(self):
         response = self.client.get(reverse("questions:check_need_appointment"))
 
-        self.assertContains(response, "Do you need to leave the online service and ask for a face-to-face appointment?")
+        self.assertRedirects(response, reverse("questions:date_of_birth"), fetch_redirect_response=False)
+
+
+    def test_responds_successfully(self):
+        DateOfBirthResponseFactory.create(
+            response_set=self.response_set, eligible=True
+        )
+
+        response = self.client.get(reverse("questions:check_need_appointment"))
+
+        self.assertEqual(response.status_code, 200)
+
 
 @tag("CheckNeedAppointment")
 class TestPostCheckNeedAppointment(TestCase):
     def setUp(self):
         self.user = login_user(self.client)
+        self.response_set = ResponseSetFactory.create(user=self.user)
 
         self.valid_params = {"value": False}
 
 
-    def test_post_redirects_if_the_user_is_not_logged_in(self):
+    def test_redirects_if_the_user_is_not_logged_in(self):
         self.client.logout()
 
         response = self.client.post(
@@ -64,69 +84,48 @@ def test_post_redirects_if_the_user_is_not_logged_in(self):
         self.assertRedirects(response, "/oidc/authenticate/?next=/check-if-you-need-an-appointment", fetch_redirect_response=False)
 
 
-    def test_post_creates_an_unsubmitted_response_set_for_the_user_when_no_response_set_exists(self):
-        self.client.post(
-            reverse("questions:check_need_appointment"),
-            self.valid_params
+    def test_redirects_when_an_submitted_response_set_exists_within_the_last_year(self):
+        self.response_set.delete()
+        ResponseSetFactory.create(
+            user=self.user,
+            recently_submitted=True
         )
 
-        response_set = self.user.responseset_set.first()
-        self.assertEqual(self.user.responseset_set.count(), 1)
-        self.assertEqual(response_set.submitted_at, None)
-        self.assertEqual(CheckNeedAppointmentResponse.objects.get(response_set=response_set).value, self.valid_params["value"])
-        self.assertEqual(response_set.user, self.user)
-
-
-    def test_post_updates_an_unsubmitted_response_set_for_the_user_when_an_unsubmitted_response_set_existso(self):
-        response_set = self.user.responseset_set.create()
-
-        self.client.post(
+        response = self.client.post(
             reverse("questions:check_need_appointment"),
             self.valid_params
         )
 
-        response_set.refresh_from_db()
-        self.assertEqual(self.user.responseset_set.count(), 1)
-        self.assertEqual(response_set.submitted_at, None)
-        self.assertEqual(CheckNeedAppointmentResponse.objects.get(response_set=response_set).value, self.valid_params["value"])
-        self.assertEqual(response_set.user, self.user)
-
+        self.assertRedirects(response, reverse("questions:confirmation"))
 
-    def test_post_creates_an_new_unsubmitted_response_set_for_the_user_when_a_non_recently_submitted_response_set_exists(self):
-        ResponseSetFactory.create(
-            user=self.user,
-            not_recently_submitted=True
-        )
 
-        self.client.post(
+    def test_redirects_if_hasnt_answered_date_of_birth(self):
+        response = self.client.post(
             reverse("questions:check_need_appointment"),
             self.valid_params
         )
 
-        self.assertEqual(self.user.responseset_set.count(), 2)
-        self.assertEqual(self.user.responseset_set.unsubmitted().count(), 1)
+        self.assertRedirects(response, reverse("questions:date_of_birth"), fetch_redirect_response=False)
 
-        response_set = self.user.responseset_set.last()
-        self.assertEqual(response_set.submitted_at, None)
-        self.assertEqual(CheckNeedAppointmentResponse.objects.get(response_set=response_set).value, self.valid_params["value"])
-        self.assertEqual(response_set.user, self.user)
 
-
-    def test_post_redirects_when_an_submitted_response_set_exists_within_the_last_year(self):
-        ResponseSetFactory.create(
-            user=self.user,
-            recently_submitted=True
+    def test_redirects_if_has_answered_date_of_birth_with_ineligible_response(self):
+        DateOfBirthResponseFactory.create(
+            response_set=self.response_set, ineligible=True
         )
 
         response = self.client.post(
             reverse("questions:check_need_appointment"),
             self.valid_params
         )
 
-        self.assertRedirects(response, reverse("questions:confirmation"))
+        self.assertRedirects(response, reverse("questions:date_of_birth"), fetch_redirect_response=False)
 
 
-    def test_post_redirects_to_the_next_page(self):
+    def test_redirects_to_the_next_page(self):
+        DateOfBirthResponseFactory.create(
+            response_set=self.response_set, eligible=True
+        )
+
         response = self.client.post(
             reverse("questions:check_need_appointment"),
             self.valid_params
@@ -135,28 +134,26 @@ def test_post_redirects_to_the_next_page(self):
         self.assertRedirects(response, reverse("questions:height"), fetch_redirect_response=False)
 
 
-    def test_post_redirects_to_book_an_appointment_page(self):
+    def test_redirects_to_book_an_appointment_page(self):
+        DateOfBirthResponseFactory.create(
+            response_set=self.response_set, eligible=True
+        )
+
         response = self.client.post(
             reverse("questions:check_need_appointment"),
             {"value": True}
         )
 
         self.assertRedirects(response, reverse("questions:book_an_appointment"))
 
-    def test_post_responds_with_422_if_the_response_fails_to_create(self):
+    def test_responds_with_422_if_the_response_fails_to_create(self):
+        DateOfBirthResponseFactory.create(
+            response_set=self.response_set, eligible=True
+        )
+
         response = self.client.post(
             reverse("questions:check_need_appointment"),
             {"value": "something not in list"}
         )
 
         self.assertEqual(response.status_code, 422)
-
-    def test_post_does_not_update_response_set_on_invalid_data(self):
-        self.client.post(
-            reverse("questions:check_need_appointment"),
-            {"value": "invalid"}
-        )
-
-        response_set = self.user.responseset_set.first()
-        if response_set:
-            self.assertFalse(CheckNeedAppointmentResponse.objects.filter(response_set=response_set).exists())

lung_cancer_screening/questions/views/check_need_appointment.py

@@ -1,5 +1,6 @@
 from django.urls import reverse, reverse_lazy
 from django.contrib.auth.mixins import LoginRequiredMixin
+from django.shortcuts import redirect
 
 from .mixins.ensure_response_set import EnsureResponseSet
 from .question_base_view import QuestionBaseView
@@ -9,7 +10,18 @@
 )
 
 
-class CheckNeedAppointmentView(LoginRequiredMixin, EnsureResponseSet, QuestionBaseView):
+class EnsureAgeEligible:
+    def dispatch(self, request, *args, **kwargs):
+        if (
+            not hasattr(request.response_set, "date_of_birth_response")
+            or not request.response_set.date_of_birth_response.is_eligible()
+        ):
+            return redirect(reverse("questions:date_of_birth"))
+        else:
+            return super().dispatch(request, *args, **kwargs)
+
+
+class CheckNeedAppointmentView(LoginRequiredMixin, EnsureResponseSet, EnsureAgeEligible, QuestionBaseView):
     template_name = "check_need_appointment.jinja"
     form_class = CheckNeedAppointmentForm
     model = CheckNeedAppointmentResponse

lung_cancer_screening/questions/views/date_of_birth.py

@@ -1,20 +1,24 @@
 from django.urls import reverse, reverse_lazy
-from django.shortcuts import redirect
 from django.contrib.auth.mixins import LoginRequiredMixin
+from django.shortcuts import redirect
 
 from .mixins.ensure_response_set import EnsureResponseSet
 from .question_base_view import QuestionBaseView
 from ..forms.date_of_birth_form import DateOfBirthForm
 from ..models.date_of_birth_response import DateOfBirthResponse
 
-class HaveYouEverSmokedRequiredMixin:
+class EnsureSmokedEligible:
     def dispatch(self, request, *args, **kwargs):
-        if not hasattr(request.response_set, "have_you_ever_smoked_response") or not request.response_set.have_you_ever_smoked_response.is_eligible():
+        if (
+            not hasattr(request.response_set, "have_you_ever_smoked_response")
+            or not request.response_set.have_you_ever_smoked_response.is_eligible()
+        ):
             return redirect(reverse("questions:have_you_ever_smoked"))
         else:
             return super().dispatch(request, *args, **kwargs)
 
-class DateOfBirthView(LoginRequiredMixin, EnsureResponseSet, HaveYouEverSmokedRequiredMixin, QuestionBaseView):
+
+class DateOfBirthView(LoginRequiredMixin, EnsureResponseSet, EnsureSmokedEligible, QuestionBaseView):
     template_name = "question_form.jinja"
     form_class = DateOfBirthForm
     model = DateOfBirthResponse