Merge pull request #2067 from cisagov/rjm/2056-domains-table-link

Issue #2056: Add a link on empty domains tables - (Bob)

src/registrar/assets/sass/_theme/_links.scss

@@ -0,0 +1,21 @@
+@use "uswds-core" as *;
+
+.dotgov-table {
+    a {
+        display: flex;
+        align-items: flex-start;
+        color: color('primary');
+
+        &:visited {
+            color: color('primary');   
+        }
+    }
+}
+
+a {
+    .usa-icon {
+        // align icon with x height
+        margin-top: units(0.5);
+        margin-right: units(0.5);
+    }
+}

src/registrar/assets/sass/_theme/_tables.scss

@@ -56,22 +56,6 @@
 .dotgov-table {
   width: 100%;
 
-  a {
-    display: flex;
-    align-items: flex-start;
-    color: color('primary');
-
-    &:visited {
-      color: color('primary');
-    }
-
-    .usa-icon {
-      // align icon with x height
-      margin-top: units(0.5);
-      margin-right: units(0.5);
-    }
-  }
-
   th[data-sortable]:not([aria-sort]) .usa-table__header__button {
     right: auto;
   }

src/registrar/assets/sass/_theme/styles.scss

@@ -10,6 +10,7 @@
 --- Custom Styles ---------------------------------*/
 @forward "base";
 @forward "typography";
+@forward "links";
 @forward "lists";
 @forward "buttons";
 @forward "forms";

src/registrar/templates/home.html

@@ -98,6 +98,14 @@
     ></div>
     {% else %}
     <p>You don't have any registered domains.</p>
+    <p class="maxw-none clearfix">
+      <a href="https://get.gov/help/faq/#do-not-see-my-domain" class="float-right-tablet display-flex flex-align-start usa-link" target="_blank">
+        <svg class="usa-icon" aria-hidden="true" focusable="false" role="img" width="24">
+          <use xlink:href="{%static 'img/sprite.svg'%}#help_outline"></use>
+        </svg>
+        Why don't I see my domain when I sign in to the registrar?
+      </a>
+    </p>
     {% endif %}
   </section>
 

src/registrar/tests/test_views.py

@@ -1,12 +1,16 @@
+from datetime import date
 from django.test import Client, TestCase, override_settings
 from django.contrib.auth import get_user_model
 
 from api.tests.common import less_console_noise_decorator
+from registrar.models.contact import Contact
 from registrar.models.domain import Domain
+from registrar.models.draft_domain import DraftDomain
+from registrar.models.user import User
 from registrar.models.user_domain_role import UserDomainRole
 from registrar.views.domain import DomainNameserversView
 
-from .common import MockEppLib  # type: ignore
+from .common import MockEppLib, less_console_noise  # type: ignore
 from unittest.mock import patch
 from django.urls import reverse
 
@@ -135,3 +139,369 @@ class TestEnvironmentVariablesEffects(TestCase):
                 self.assertEqual(contact_page_500.status_code, 500)
 
                 self.assertNotContains(contact_page_500, "You are on a test site.")
+
+
+class HomeTests(TestWithUser):
+    """A series of tests that target the two tables on home.html"""
+
+    def setUp(self):
+        super().setUp()
+        self.client.force_login(self.user)
+
+    def tearDown(self):
+        super().tearDown()
+        Contact.objects.all().delete()
+
+    def test_empty_domain_table(self):
+        response = self.client.get("/")
+        self.assertContains(response, "You don't have any registered domains.")
+        self.assertContains(response, "Why don't I see my domain when I sign in to the registrar?")
+
+    def test_home_lists_domain_requests(self):
+        response = self.client.get("/")
+        self.assertNotContains(response, "igorville.gov")
+        site = DraftDomain.objects.create(name="igorville.gov")
+        domain_request = DomainRequest.objects.create(creator=self.user, requested_domain=site)
+        response = self.client.get("/")
+
+        # count = 7 because of screenreader content
+        self.assertContains(response, "igorville.gov", count=7)
+
+        # clean up
+        domain_request.delete()
+
+    def test_state_help_text(self):
+        """Tests if each domain state has help text"""
+
+        # Get the expected text content of each state
+        deleted_text = "This domain has been removed and " "is no longer registered to your organization."
+        dns_needed_text = "Before this domain can be used, " "you’ll need to add name server addresses."
+        ready_text = "This domain has name servers and is ready for use."
+        on_hold_text = (
+            "This domain is administratively paused, "
+            "so it can’t be edited and won’t resolve in DNS. "
+            "Contact help@get.gov for details."
+        )
+        deleted_text = "This domain has been removed and " "is no longer registered to your organization."
+        # Generate a mapping of domain names, the state, and expected messages for the subtest
+        test_cases = [
+            ("deleted.gov", Domain.State.DELETED, deleted_text),
+            ("dnsneeded.gov", Domain.State.DNS_NEEDED, dns_needed_text),
+            ("unknown.gov", Domain.State.UNKNOWN, dns_needed_text),
+            ("onhold.gov", Domain.State.ON_HOLD, on_hold_text),
+            ("ready.gov", Domain.State.READY, ready_text),
+        ]
+        for domain_name, state, expected_message in test_cases:
+            with self.subTest(domain_name=domain_name, state=state, expected_message=expected_message):
+                # Create a domain and a UserRole with the given params
+                test_domain, _ = Domain.objects.get_or_create(name=domain_name, state=state)
+                test_domain.expiration_date = date.today()
+                test_domain.save()
+
+                user_role, _ = UserDomainRole.objects.get_or_create(
+                    user=self.user, domain=test_domain, role=UserDomainRole.Roles.MANAGER
+                )
+
+                # Grab the home page
+                response = self.client.get("/")
+
+                # Make sure the user can actually see the domain.
+                # We expect two instances because of SR content.
+                self.assertContains(response, domain_name, count=2)
+
+                # Check that we have the right text content.
+                self.assertContains(response, expected_message, count=1)
+
+                # Delete the role and domain to ensure we're testing in isolation
+                user_role.delete()
+                test_domain.delete()
+
+    def test_state_help_text_expired(self):
+        """Tests if each domain state has help text when expired"""
+        expired_text = "This domain has expired, but it is still online. " "To renew this domain, contact help@get.gov."
+        test_domain, _ = Domain.objects.get_or_create(name="expired.gov", state=Domain.State.READY)
+        test_domain.expiration_date = date(2011, 10, 10)
+        test_domain.save()
+
+        UserDomainRole.objects.get_or_create(user=self.user, domain=test_domain, role=UserDomainRole.Roles.MANAGER)
+
+        # Grab the home page
+        response = self.client.get("/")
+
+        # Make sure the user can actually see the domain.
+        # We expect two instances because of SR content.
+        self.assertContains(response, "expired.gov", count=2)
+
+        # Check that we have the right text content.
+        self.assertContains(response, expired_text, count=1)
+
+    def test_state_help_text_no_expiration_date(self):
+        """Tests if each domain state has help text when expiration date is None"""
+
+        # == Test a expiration of None for state ready. This should be expired. == #
+        expired_text = "This domain has expired, but it is still online. " "To renew this domain, contact help@get.gov."
+        test_domain, _ = Domain.objects.get_or_create(name="imexpired.gov", state=Domain.State.READY)
+        test_domain.expiration_date = None
+        test_domain.save()
+
+        UserDomainRole.objects.get_or_create(user=self.user, domain=test_domain, role=UserDomainRole.Roles.MANAGER)
+
+        # Grab the home page
+        response = self.client.get("/")
+
+        # Make sure the user can actually see the domain.
+        # We expect two instances because of SR content.
+        self.assertContains(response, "imexpired.gov", count=2)
+
+        # Make sure the expiration date is None
+        self.assertEqual(test_domain.expiration_date, None)
+
+        # Check that we have the right text content.
+        self.assertContains(response, expired_text, count=1)
+
+        # == Test a expiration of None for state unknown. This should not display expired text. == #
+        unknown_text = "Before this domain can be used, " "you’ll need to add name server addresses."
+        test_domain_2, _ = Domain.objects.get_or_create(name="notexpired.gov", state=Domain.State.UNKNOWN)
+        test_domain_2.expiration_date = None
+        test_domain_2.save()
+
+        UserDomainRole.objects.get_or_create(user=self.user, domain=test_domain_2, role=UserDomainRole.Roles.MANAGER)
+
+        # Grab the home page
+        response = self.client.get("/")
+
+        # Make sure the user can actually see the domain.
+        # We expect two instances because of SR content.
+        self.assertContains(response, "notexpired.gov", count=2)
+
+        # Make sure the expiration date is None
+        self.assertEqual(test_domain_2.expiration_date, None)
+
+        # Check that we have the right text content.
+        self.assertContains(response, unknown_text, count=1)
+
+    def test_home_deletes_withdrawn_domain_request(self):
+        """Tests if the user can delete a DomainRequest in the 'withdrawn' status"""
+
+        site = DraftDomain.objects.create(name="igorville.gov")
+        domain_request = DomainRequest.objects.create(
+            creator=self.user, requested_domain=site, status=DomainRequest.DomainRequestStatus.WITHDRAWN
+        )
+
+        # Ensure that igorville.gov exists on the page
+        home_page = self.client.get("/")
+        self.assertContains(home_page, "igorville.gov")
+
+        # Check if the delete button exists. We can do this by checking for its id and text content.
+        self.assertContains(home_page, "Delete")
+        self.assertContains(home_page, "button-toggle-delete-domain-alert-1")
+
+        # Trigger the delete logic
+        response = self.client.post(reverse("domain-request-delete", kwargs={"pk": domain_request.pk}), follow=True)
+
+        self.assertNotContains(response, "igorville.gov")
+
+        # clean up
+        domain_request.delete()
+
+    def test_home_deletes_started_domain_request(self):
+        """Tests if the user can delete a DomainRequest in the 'started' status"""
+
+        site = DraftDomain.objects.create(name="igorville.gov")
+        domain_request = DomainRequest.objects.create(
+            creator=self.user, requested_domain=site, status=DomainRequest.DomainRequestStatus.STARTED
+        )
+
+        # Ensure that igorville.gov exists on the page
+        home_page = self.client.get("/")
+        self.assertContains(home_page, "igorville.gov")
+
+        # Check if the delete button exists. We can do this by checking for its id and text content.
+        self.assertContains(home_page, "Delete")
+        self.assertContains(home_page, "button-toggle-delete-domain-alert-1")
+
+        # Trigger the delete logic
+        response = self.client.post(reverse("domain-request-delete", kwargs={"pk": domain_request.pk}), follow=True)
+
+        self.assertNotContains(response, "igorville.gov")
+
+        # clean up
+        domain_request.delete()
+
+    def test_home_doesnt_delete_other_domain_requests(self):
+        """Tests to ensure the user can't delete domain requests not in the status of STARTED or WITHDRAWN"""
+
+        # Given that we are including a subset of items that can be deleted while excluding the rest,
+        # subTest is appropriate here as otherwise we would need many duplicate tests for the same reason.
+        with less_console_noise():
+            draft_domain = DraftDomain.objects.create(name="igorville.gov")
+            for status in DomainRequest.DomainRequestStatus:
+                if status not in [
+                    DomainRequest.DomainRequestStatus.STARTED,
+                    DomainRequest.DomainRequestStatus.WITHDRAWN,
+                ]:
+                    with self.subTest(status=status):
+                        domain_request = DomainRequest.objects.create(
+                            creator=self.user, requested_domain=draft_domain, status=status
+                        )
+
+                        # Trigger the delete logic
+                        response = self.client.post(
+                            reverse("domain-request-delete", kwargs={"pk": domain_request.pk}), follow=True
+                        )
+
+                        # Check for a 403 error - the end user should not be allowed to do this
+                        self.assertEqual(response.status_code, 403)
+
+                        desired_domain_request = DomainRequest.objects.filter(requested_domain=draft_domain)
+
+                        # Make sure the DomainRequest wasn't deleted
+                        self.assertEqual(desired_domain_request.count(), 1)
+
+                        # clean up
+                        domain_request.delete()
+
+    def test_home_deletes_domain_request_and_orphans(self):
+        """Tests if delete for DomainRequest deletes orphaned Contact objects"""
+
+        # Create the site and contacts to delete (orphaned)
+        contact = Contact.objects.create(
+            first_name="Henry",
+            last_name="Mcfakerson",
+        )
+        contact_shared = Contact.objects.create(
+            first_name="Relative",
+            last_name="Aether",
+        )
+
+        # Create two non-orphaned contacts
+        contact_2 = Contact.objects.create(
+            first_name="Saturn",
+            last_name="Mars",
+        )
+
+        # Attach a user object to a contact (should not be deleted)
+        contact_user, _ = Contact.objects.get_or_create(user=self.user)
+
+        site = DraftDomain.objects.create(name="igorville.gov")
+        domain_request = DomainRequest.objects.create(
+            creator=self.user,
+            requested_domain=site,
+            status=DomainRequest.DomainRequestStatus.WITHDRAWN,
+            authorizing_official=contact,
+            submitter=contact_user,
+        )
+        domain_request.other_contacts.set([contact_2])
+
+        # Create a second domain request to attach contacts to
+        site_2 = DraftDomain.objects.create(name="teaville.gov")
+        domain_request_2 = DomainRequest.objects.create(
+            creator=self.user,
+            requested_domain=site_2,
+            status=DomainRequest.DomainRequestStatus.STARTED,
+            authorizing_official=contact_2,
+            submitter=contact_shared,
+        )
+        domain_request_2.other_contacts.set([contact_shared])
+
+        # Ensure that igorville.gov exists on the page
+        home_page = self.client.get("/")
+        self.assertContains(home_page, "igorville.gov")
+
+        # Trigger the delete logic
+        response = self.client.post(reverse("domain-request-delete", kwargs={"pk": domain_request.pk}), follow=True)
+
+        # igorville is now deleted
+        self.assertNotContains(response, "igorville.gov")
+
+        # Check if the orphaned contact was deleted
+        orphan = Contact.objects.filter(id=contact.id)
+        self.assertFalse(orphan.exists())
+
+        # All non-orphan contacts should still exist and are unaltered
+        try:
+            current_user = Contact.objects.filter(id=contact_user.id).get()
+        except Contact.DoesNotExist:
+            self.fail("contact_user (a non-orphaned contact) was deleted")
+
+        self.assertEqual(current_user, contact_user)
+        try:
+            edge_case = Contact.objects.filter(id=contact_2.id).get()
+        except Contact.DoesNotExist:
+            self.fail("contact_2 (a non-orphaned contact) was deleted")
+
+        self.assertEqual(edge_case, contact_2)
+
+    def test_home_deletes_domain_request_and_shared_orphans(self):
+        """Test the edge case for an object that will become orphaned after a delete
+        (but is not an orphan at the time of deletion)"""
+
+        # Create the site and contacts to delete (orphaned)
+        contact = Contact.objects.create(
+            first_name="Henry",
+            last_name="Mcfakerson",
+        )
+        contact_shared = Contact.objects.create(
+            first_name="Relative",
+            last_name="Aether",
+        )
+
+        # Create two non-orphaned contacts
+        contact_2 = Contact.objects.create(
+            first_name="Saturn",
+            last_name="Mars",
+        )
+
+        # Attach a user object to a contact (should not be deleted)
+        contact_user, _ = Contact.objects.get_or_create(user=self.user)
+
+        site = DraftDomain.objects.create(name="igorville.gov")
+        domain_request = DomainRequest.objects.create(
+            creator=self.user,
+            requested_domain=site,
+            status=DomainRequest.DomainRequestStatus.WITHDRAWN,
+            authorizing_official=contact,
+            submitter=contact_user,
+        )
+        domain_request.other_contacts.set([contact_2])
+
+        # Create a second domain request to attach contacts to
+        site_2 = DraftDomain.objects.create(name="teaville.gov")
+        domain_request_2 = DomainRequest.objects.create(
+            creator=self.user,
+            requested_domain=site_2,
+            status=DomainRequest.DomainRequestStatus.STARTED,
+            authorizing_official=contact_2,
+            submitter=contact_shared,
+        )
+        domain_request_2.other_contacts.set([contact_shared])
+
+        home_page = self.client.get("/")
+        self.assertContains(home_page, "teaville.gov")
+
+        # Trigger the delete logic
+        response = self.client.post(reverse("domain-request-delete", kwargs={"pk": domain_request_2.pk}), follow=True)
+
+        self.assertNotContains(response, "teaville.gov")
+
+        # Check if the orphaned contact was deleted
+        orphan = Contact.objects.filter(id=contact_shared.id)
+        self.assertFalse(orphan.exists())
+
+    def test_domain_request_form_view(self):
+        response = self.client.get("/request/", follow=True)
+        self.assertContains(
+            response,
+            "You’re about to start your .gov domain request.",
+        )
+
+    def test_domain_request_form_with_ineligible_user(self):
+        """Domain request form not accessible for an ineligible user.
+        This test should be solid enough since all domain request wizard
+        views share the same permissions class"""
+        self.user.status = User.RESTRICTED
+        self.user.save()
+
+        with less_console_noise():
+            response = self.client.get("/request/", follow=True)
+            self.assertEqual(response.status_code, 403)

src/registrar/tests/test_views_request.py

@@ -3,7 +3,6 @@ from unittest.mock import Mock
 
 from django.conf import settings
 from django.urls import reverse
-from datetime import date
 
 from .common import MockSESClient, completed_domain_request  # type: ignore
 from django_webtest import WebTest  # type: ignore
@@ -17,7 +16,6 @@ from registrar.models import (
     Contact,
     User,
     Website,
-    UserDomainRole,
 )
 from registrar.views.domain_request import DomainRequestWizard, Step
 
@@ -2603,364 +2601,3 @@ class TestWizardUnlockingSteps(TestWithUser, WebTest):
 
         else:
             self.fail(f"Expected a redirect, but got a different response: {response}")
-
-
-class HomeTests(TestWithUser):
-    """A series of tests that target the two tables on home.html"""
-
-    def setUp(self):
-        super().setUp()
-        self.client.force_login(self.user)
-
-    def tearDown(self):
-        super().tearDown()
-        Contact.objects.all().delete()
-
-    def test_home_lists_domain_requests(self):
-        response = self.client.get("/")
-        self.assertNotContains(response, "igorville.gov")
-        site = DraftDomain.objects.create(name="igorville.gov")
-        domain_request = DomainRequest.objects.create(creator=self.user, requested_domain=site)
-        response = self.client.get("/")
-
-        # count = 7 because of screenreader content
-        self.assertContains(response, "igorville.gov", count=7)
-
-        # clean up
-        domain_request.delete()
-
-    def test_state_help_text(self):
-        """Tests if each domain state has help text"""
-
-        # Get the expected text content of each state
-        deleted_text = "This domain has been removed and " "is no longer registered to your organization."
-        dns_needed_text = "Before this domain can be used, " "you’ll need to add name server addresses."
-        ready_text = "This domain has name servers and is ready for use."
-        on_hold_text = (
-            "This domain is administratively paused, "
-            "so it can’t be edited and won’t resolve in DNS. "
-            "Contact help@get.gov for details."
-        )
-        deleted_text = "This domain has been removed and " "is no longer registered to your organization."
-        # Generate a mapping of domain names, the state, and expected messages for the subtest
-        test_cases = [
-            ("deleted.gov", Domain.State.DELETED, deleted_text),
-            ("dnsneeded.gov", Domain.State.DNS_NEEDED, dns_needed_text),
-            ("unknown.gov", Domain.State.UNKNOWN, dns_needed_text),
-            ("onhold.gov", Domain.State.ON_HOLD, on_hold_text),
-            ("ready.gov", Domain.State.READY, ready_text),
-        ]
-        for domain_name, state, expected_message in test_cases:
-            with self.subTest(domain_name=domain_name, state=state, expected_message=expected_message):
-                # Create a domain and a UserRole with the given params
-                test_domain, _ = Domain.objects.get_or_create(name=domain_name, state=state)
-                test_domain.expiration_date = date.today()
-                test_domain.save()
-
-                user_role, _ = UserDomainRole.objects.get_or_create(
-                    user=self.user, domain=test_domain, role=UserDomainRole.Roles.MANAGER
-                )
-
-                # Grab the home page
-                response = self.client.get("/")
-
-                # Make sure the user can actually see the domain.
-                # We expect two instances because of SR content.
-                self.assertContains(response, domain_name, count=2)
-
-                # Check that we have the right text content.
-                self.assertContains(response, expected_message, count=1)
-
-                # Delete the role and domain to ensure we're testing in isolation
-                user_role.delete()
-                test_domain.delete()
-
-    def test_state_help_text_expired(self):
-        """Tests if each domain state has help text when expired"""
-        expired_text = "This domain has expired, but it is still online. " "To renew this domain, contact help@get.gov."
-        test_domain, _ = Domain.objects.get_or_create(name="expired.gov", state=Domain.State.READY)
-        test_domain.expiration_date = date(2011, 10, 10)
-        test_domain.save()
-
-        UserDomainRole.objects.get_or_create(user=self.user, domain=test_domain, role=UserDomainRole.Roles.MANAGER)
-
-        # Grab the home page
-        response = self.client.get("/")
-
-        # Make sure the user can actually see the domain.
-        # We expect two instances because of SR content.
-        self.assertContains(response, "expired.gov", count=2)
-
-        # Check that we have the right text content.
-        self.assertContains(response, expired_text, count=1)
-
-    def test_state_help_text_no_expiration_date(self):
-        """Tests if each domain state has help text when expiration date is None"""
-
-        # == Test a expiration of None for state ready. This should be expired. == #
-        expired_text = "This domain has expired, but it is still online. " "To renew this domain, contact help@get.gov."
-        test_domain, _ = Domain.objects.get_or_create(name="imexpired.gov", state=Domain.State.READY)
-        test_domain.expiration_date = None
-        test_domain.save()
-
-        UserDomainRole.objects.get_or_create(user=self.user, domain=test_domain, role=UserDomainRole.Roles.MANAGER)
-
-        # Grab the home page
-        response = self.client.get("/")
-
-        # Make sure the user can actually see the domain.
-        # We expect two instances because of SR content.
-        self.assertContains(response, "imexpired.gov", count=2)
-
-        # Make sure the expiration date is None
-        self.assertEqual(test_domain.expiration_date, None)
-
-        # Check that we have the right text content.
-        self.assertContains(response, expired_text, count=1)
-
-        # == Test a expiration of None for state unknown. This should not display expired text. == #
-        unknown_text = "Before this domain can be used, " "you’ll need to add name server addresses."
-        test_domain_2, _ = Domain.objects.get_or_create(name="notexpired.gov", state=Domain.State.UNKNOWN)
-        test_domain_2.expiration_date = None
-        test_domain_2.save()
-
-        UserDomainRole.objects.get_or_create(user=self.user, domain=test_domain_2, role=UserDomainRole.Roles.MANAGER)
-
-        # Grab the home page
-        response = self.client.get("/")
-
-        # Make sure the user can actually see the domain.
-        # We expect two instances because of SR content.
-        self.assertContains(response, "notexpired.gov", count=2)
-
-        # Make sure the expiration date is None
-        self.assertEqual(test_domain_2.expiration_date, None)
-
-        # Check that we have the right text content.
-        self.assertContains(response, unknown_text, count=1)
-
-    def test_home_deletes_withdrawn_domain_request(self):
-        """Tests if the user can delete a DomainRequest in the 'withdrawn' status"""
-
-        site = DraftDomain.objects.create(name="igorville.gov")
-        domain_request = DomainRequest.objects.create(
-            creator=self.user, requested_domain=site, status=DomainRequest.DomainRequestStatus.WITHDRAWN
-        )
-
-        # Ensure that igorville.gov exists on the page
-        home_page = self.client.get("/")
-        self.assertContains(home_page, "igorville.gov")
-
-        # Check if the delete button exists. We can do this by checking for its id and text content.
-        self.assertContains(home_page, "Delete")
-        self.assertContains(home_page, "button-toggle-delete-domain-alert-1")
-
-        # Trigger the delete logic
-        response = self.client.post(reverse("domain-request-delete", kwargs={"pk": domain_request.pk}), follow=True)
-
-        self.assertNotContains(response, "igorville.gov")
-
-        # clean up
-        domain_request.delete()
-
-    def test_home_deletes_started_domain_request(self):
-        """Tests if the user can delete a DomainRequest in the 'started' status"""
-
-        site = DraftDomain.objects.create(name="igorville.gov")
-        domain_request = DomainRequest.objects.create(
-            creator=self.user, requested_domain=site, status=DomainRequest.DomainRequestStatus.STARTED
-        )
-
-        # Ensure that igorville.gov exists on the page
-        home_page = self.client.get("/")
-        self.assertContains(home_page, "igorville.gov")
-
-        # Check if the delete button exists. We can do this by checking for its id and text content.
-        self.assertContains(home_page, "Delete")
-        self.assertContains(home_page, "button-toggle-delete-domain-alert-1")
-
-        # Trigger the delete logic
-        response = self.client.post(reverse("domain-request-delete", kwargs={"pk": domain_request.pk}), follow=True)
-
-        self.assertNotContains(response, "igorville.gov")
-
-        # clean up
-        domain_request.delete()
-
-    def test_home_doesnt_delete_other_domain_requests(self):
-        """Tests to ensure the user can't delete domain requests not in the status of STARTED or WITHDRAWN"""
-
-        # Given that we are including a subset of items that can be deleted while excluding the rest,
-        # subTest is appropriate here as otherwise we would need many duplicate tests for the same reason.
-        with less_console_noise():
-            draft_domain = DraftDomain.objects.create(name="igorville.gov")
-            for status in DomainRequest.DomainRequestStatus:
-                if status not in [
-                    DomainRequest.DomainRequestStatus.STARTED,
-                    DomainRequest.DomainRequestStatus.WITHDRAWN,
-                ]:
-                    with self.subTest(status=status):
-                        domain_request = DomainRequest.objects.create(
-                            creator=self.user, requested_domain=draft_domain, status=status
-                        )
-
-                        # Trigger the delete logic
-                        response = self.client.post(
-                            reverse("domain-request-delete", kwargs={"pk": domain_request.pk}), follow=True
-                        )
-
-                        # Check for a 403 error - the end user should not be allowed to do this
-                        self.assertEqual(response.status_code, 403)
-
-                        desired_domain_request = DomainRequest.objects.filter(requested_domain=draft_domain)
-
-                        # Make sure the DomainRequest wasn't deleted
-                        self.assertEqual(desired_domain_request.count(), 1)
-
-                        # clean up
-                        domain_request.delete()
-
-    def test_home_deletes_domain_request_and_orphans(self):
-        """Tests if delete for DomainRequest deletes orphaned Contact objects"""
-
-        # Create the site and contacts to delete (orphaned)
-        contact = Contact.objects.create(
-            first_name="Henry",
-            last_name="Mcfakerson",
-        )
-        contact_shared = Contact.objects.create(
-            first_name="Relative",
-            last_name="Aether",
-        )
-
-        # Create two non-orphaned contacts
-        contact_2 = Contact.objects.create(
-            first_name="Saturn",
-            last_name="Mars",
-        )
-
-        # Attach a user object to a contact (should not be deleted)
-        contact_user, _ = Contact.objects.get_or_create(user=self.user)
-
-        site = DraftDomain.objects.create(name="igorville.gov")
-        domain_request = DomainRequest.objects.create(
-            creator=self.user,
-            requested_domain=site,
-            status=DomainRequest.DomainRequestStatus.WITHDRAWN,
-            authorizing_official=contact,
-            submitter=contact_user,
-        )
-        domain_request.other_contacts.set([contact_2])
-
-        # Create a second domain request to attach contacts to
-        site_2 = DraftDomain.objects.create(name="teaville.gov")
-        domain_request_2 = DomainRequest.objects.create(
-            creator=self.user,
-            requested_domain=site_2,
-            status=DomainRequest.DomainRequestStatus.STARTED,
-            authorizing_official=contact_2,
-            submitter=contact_shared,
-        )
-        domain_request_2.other_contacts.set([contact_shared])
-
-        # Ensure that igorville.gov exists on the page
-        home_page = self.client.get("/")
-        self.assertContains(home_page, "igorville.gov")
-
-        # Trigger the delete logic
-        response = self.client.post(reverse("domain-request-delete", kwargs={"pk": domain_request.pk}), follow=True)
-
-        # igorville is now deleted
-        self.assertNotContains(response, "igorville.gov")
-
-        # Check if the orphaned contact was deleted
-        orphan = Contact.objects.filter(id=contact.id)
-        self.assertFalse(orphan.exists())
-
-        # All non-orphan contacts should still exist and are unaltered
-        try:
-            current_user = Contact.objects.filter(id=contact_user.id).get()
-        except Contact.DoesNotExist:
-            self.fail("contact_user (a non-orphaned contact) was deleted")
-
-        self.assertEqual(current_user, contact_user)
-        try:
-            edge_case = Contact.objects.filter(id=contact_2.id).get()
-        except Contact.DoesNotExist:
-            self.fail("contact_2 (a non-orphaned contact) was deleted")
-
-        self.assertEqual(edge_case, contact_2)
-
-    def test_home_deletes_domain_request_and_shared_orphans(self):
-        """Test the edge case for an object that will become orphaned after a delete
-        (but is not an orphan at the time of deletion)"""
-
-        # Create the site and contacts to delete (orphaned)
-        contact = Contact.objects.create(
-            first_name="Henry",
-            last_name="Mcfakerson",
-        )
-        contact_shared = Contact.objects.create(
-            first_name="Relative",
-            last_name="Aether",
-        )
-
-        # Create two non-orphaned contacts
-        contact_2 = Contact.objects.create(
-            first_name="Saturn",
-            last_name="Mars",
-        )
-
-        # Attach a user object to a contact (should not be deleted)
-        contact_user, _ = Contact.objects.get_or_create(user=self.user)
-
-        site = DraftDomain.objects.create(name="igorville.gov")
-        domain_request = DomainRequest.objects.create(
-            creator=self.user,
-            requested_domain=site,
-            status=DomainRequest.DomainRequestStatus.WITHDRAWN,
-            authorizing_official=contact,
-            submitter=contact_user,
-        )
-        domain_request.other_contacts.set([contact_2])
-
-        # Create a second domain request to attach contacts to
-        site_2 = DraftDomain.objects.create(name="teaville.gov")
-        domain_request_2 = DomainRequest.objects.create(
-            creator=self.user,
-            requested_domain=site_2,
-            status=DomainRequest.DomainRequestStatus.STARTED,
-            authorizing_official=contact_2,
-            submitter=contact_shared,
-        )
-        domain_request_2.other_contacts.set([contact_shared])
-
-        home_page = self.client.get("/")
-        self.assertContains(home_page, "teaville.gov")
-
-        # Trigger the delete logic
-        response = self.client.post(reverse("domain-request-delete", kwargs={"pk": domain_request_2.pk}), follow=True)
-
-        self.assertNotContains(response, "teaville.gov")
-
-        # Check if the orphaned contact was deleted
-        orphan = Contact.objects.filter(id=contact_shared.id)
-        self.assertFalse(orphan.exists())
-
-    def test_domain_request_form_view(self):
-        response = self.client.get("/request/", follow=True)
-        self.assertContains(
-            response,
-            "You’re about to start your .gov domain request.",
-        )
-
-    def test_domain_request_form_with_ineligible_user(self):
-        """Domain request form not accessible for an ineligible user.
-        This test should be solid enough since all domain request wizard
-        views share the same permissions class"""
-        self.user.status = User.RESTRICTED
-        self.user.save()
-
-        with less_console_noise():
-            response = self.client.get("/request/", follow=True)
-            self.assertEqual(response.status_code, 403)