From bb61ce9f642eb853a8bb0d0b599f9494bff2b09d Mon Sep 17 00:00:00 2001 From: Rachid Mrad Date: Fri, 6 Oct 2023 13:26:07 -0400 Subject: [PATCH] 50% coverage on DNSSEC code (testing for statuses and flows) --- src/registrar/tests/test_views.py | 181 ++++++++++++++++++++++++++---- 1 file changed, 160 insertions(+), 21 deletions(-) diff --git a/src/registrar/tests/test_views.py b/src/registrar/tests/test_views.py index 83e9a8749..8e984be85 100644 --- a/src/registrar/tests/test_views.py +++ b/src/registrar/tests/test_views.py @@ -1071,21 +1071,51 @@ class TestWithDomainPermissions(TestWithUser): def setUp(self): super().setUp() self.domain, _ = Domain.objects.get_or_create(name="igorville.gov") + self.domain_dsdata, _ = Domain.objects.get_or_create(name="dnssec-dsdata.gov") + self.domain_multdsdata, _ = Domain.objects.get_or_create(name="dnssec-multdsdata.gov") + self.domain_keydata, _ = Domain.objects.get_or_create(name="dnssec-keydata.gov") + # We could simply use domain (igoreville) but this will be more readable in tests + # that inherit this setUp + self.domain_dnssec_none, _ = Domain.objects.get_or_create(name="dnssec-none.gov") self.domain_information, _ = DomainInformation.objects.get_or_create( creator=self.user, domain=self.domain ) + DomainInformation.objects.get_or_create( + creator=self.user, domain=self.domain_dsdata + ) + DomainInformation.objects.get_or_create( + creator=self.user, domain=self.domain_multdsdata + ) + DomainInformation.objects.get_or_create( + creator=self.user, domain=self.domain_keydata + ) + DomainInformation.objects.get_or_create( + creator=self.user, domain=self.domain_dnssec_none + ) self.role, _ = UserDomainRole.objects.get_or_create( user=self.user, domain=self.domain, role=UserDomainRole.Roles.ADMIN ) + UserDomainRole.objects.get_or_create( + user=self.user, domain=self.domain_dsdata, role=UserDomainRole.Roles.ADMIN + ) + UserDomainRole.objects.get_or_create( + user=self.user, domain=self.domain_multdsdata, role=UserDomainRole.Roles.ADMIN + ) + UserDomainRole.objects.get_or_create( + user=self.user, domain=self.domain_keydata, role=UserDomainRole.Roles.ADMIN + ) + UserDomainRole.objects.get_or_create( + user=self.user, domain=self.domain_dnssec_none, role=UserDomainRole.Roles.ADMIN + ) def tearDown(self): try: - self.domain_information.delete() + UserDomainRole.objects.all().delete() if hasattr(self.domain, "contacts"): self.domain.contacts.all().delete() DomainApplication.objects.all().delete() - self.domain.delete() - self.role.delete() + Domain.objects.all().delete() + UserDomainRole.objects.all().delete() except ValueError: # pass if already deleted pass super().tearDown() @@ -1143,17 +1173,25 @@ class TestDomainOverview(TestWithDomainPermissions, WebTest): home_page = self.app.get("/") self.assertContains(home_page, "igorville.gov") # click the "Edit" link - detail_page = home_page.click("Manage") + detail_page = home_page.click("Manage", index=0) self.assertContains(detail_page, "igorville.gov") self.assertContains(detail_page, "Status") + + def test_domain_overview_blocked_for_ineligible_user(self): + """We could easily duplicate this test for all domain management + views, but a single url test should be solid enough since all domain + management pages share the same permissions class""" + self.user.status = User.RESTRICTED + self.user.save() + home_page = self.app.get("/") + self.assertContains(home_page, "igorville.gov") + with less_console_noise(): + response = self.client.get(reverse("domain", kwargs={"pk": self.domain.id})) + self.assertEqual(response.status_code, 403) -class TestDomainUserManagement(TestWithDomainPermissions, WebTest): - def setUp(self): - super().setUp() - self.app.set_user(self.user.username) - self.client.force_login(self.user) - +class TestDomainUserManagement(TestDomainOverview): + def test_domain_user_management(self): response = self.client.get( reverse("domain-users", kwargs={"pk": self.domain.id}) @@ -1311,6 +1349,8 @@ class TestDomainUserManagement(TestWithDomainPermissions, WebTest): # Now load the home page and make sure our domain appears there home_page = self.app.get(reverse("home")) self.assertContains(home_page, self.domain.name) + +class TestDomainNameservers(TestDomainOverview): def test_domain_nameservers(self): """Can load domain's nameservers page.""" @@ -1362,6 +1402,8 @@ class TestDomainUserManagement(TestWithDomainPermissions, WebTest): # error text appears twice, once at the top of the page, once around # the field. self.assertContains(result, "This field is required", count=2, status_code=200) + +class TestDomainAuthorizingOfficial(TestDomainOverview): def test_domain_authorizing_official(self): """Can load domain's authorizing official page.""" @@ -1380,6 +1422,8 @@ class TestDomainUserManagement(TestWithDomainPermissions, WebTest): reverse("domain-authorizing-official", kwargs={"pk": self.domain.id}) ) self.assertContains(page, "Testy") + +class TestDomainOrganization(TestDomainOverview): def test_domain_org_name_address(self): """Can load domain's org name and mailing address page.""" @@ -1416,6 +1460,8 @@ class TestDomainUserManagement(TestWithDomainPermissions, WebTest): self.assertContains(success_result_page, "Not igorville") self.assertContains(success_result_page, "Faketown") + +class TestDomainContactInformation(TestDomainOverview): def test_domain_your_contact_information(self): """Can load domain's your contact information page.""" @@ -1432,6 +1478,8 @@ class TestDomainUserManagement(TestWithDomainPermissions, WebTest): reverse("domain-your-contact-information", kwargs={"pk": self.domain.id}) ) self.assertContains(page, "Testy") + +class TestDomainSecurityEmail(TestDomainOverview): def test_domain_security_email(self): """Can load domain's security email page.""" @@ -1465,18 +1513,109 @@ class TestDomainUserManagement(TestWithDomainPermissions, WebTest): self.assertContains( success_page, "The security email for this domain have been updated" ) + + +class TestDomainDNSSEC(TestDomainOverview): + + """MockEPPLib is already inherited.""" + + def test_dnssec_page_refreshes_enable_button(self): + """DNSSEC overview page loads when domain has no DNSSEC data + and shows a 'Enable DNSSEC' button. When button is clicked the template + updates. When user navigates away then comes back to the page, the + 'Enable DNSSEC' button is shown again.""" + # home_page = self.app.get("/") + + page = self.client.get( + reverse("domain-dns-dnssec", kwargs={"pk": self.domain.id}) + ) + self.assertContains(page, "Enable DNSSEC") + + # Prepare the data for the POST request + post_data = { + 'enable_dnssec': 'Enable DNSSEC', # Replace with the actual form field and value + # Add other form fields as needed + } + updated_page = self.client.post(reverse("domain-dns-dnssec", kwargs={"pk": self.domain.id}), post_data, follow=True) + + self.assertEqual(updated_page.status_code, 200) + + self.assertContains(updated_page, "Add DS Data") + self.assertContains(updated_page, "Add Key Data") + + self.app.get("/") + + back_to_page = self.client.get( + reverse("domain-dns-dnssec", kwargs={"pk": self.domain.id}) + ) + self.assertContains(back_to_page, "Enable DNSSEC") + + + def test_dnssec_page_loads_with_data_in_domain(self): + """DNSSEC overview page loads when domain has DNSSEC data + and the template contains a button to disable DNSSEC.""" + + page = self.client.get( + reverse("domain-dns-dnssec", kwargs={"pk": self.domain_multdsdata.id}) + ) + self.assertContains(page, "Disable DNSSEC") + + def test_ds_form_loads_with_no_domain_data(self): + """DNSSEC Add DS Data page loads when there is no + domain DNSSEC data and shows a button to Add DS Data record""" + + page = self.client.get( + reverse("domain-dns-dnssec-dsdata", kwargs={"pk": self.domain_dnssec_none.id}) + ) + self.assertContains(page, "Add DS Data record") + + def test_ds_form_loads_with_ds_data(self): + """DNSSEC Add DS Data page loads when there is + domain DNSSEC DS data and shows the data""" + + page = self.client.get( + reverse("domain-dns-dnssec-dsdata", kwargs={"pk": self.domain_dsdata.id}) + ) + self.assertContains(page, "DS Data record 1") + + def test_ds_form_loads_with_key_data(self): + """DNSSEC Add DS Data page loads when there is + domain DNSSEC KEY data and shows an alert""" + + page = self.client.get( + reverse("domain-dns-dnssec-dsdata", kwargs={"pk": self.domain_keydata.id}) + ) + self.assertContains(page, "Warning, you cannot add DS Data") + + def test_key_form_loads_with_no_domain_data(self): + """DNSSEC Add Key Data page loads when there is no + domain DNSSEC data and shows a button to Add DS Key record""" + + page = self.client.get( + reverse("domain-dns-dnssec-keydata", kwargs={"pk": self.domain_dnssec_none.id}) + ) + self.assertContains(page, "Add DS Key record") + + def test_key_form_loads_with_key_data(self): + """DNSSEC Add Key Data page loads when there is + domain DNSSEC Key data and shows the data""" + + page = self.client.get( + reverse("domain-dns-dnssec-keydata", kwargs={"pk": self.domain_keydata.id}) + ) + self.assertContains(page, "DS Data record 1") + + def test_key_form_loads_with_ds_data(self): + """DNSSEC Add Key Data page loads when there is + domain DNSSEC DS data and shows an alert""" + + page = self.client.get( + reverse("domain-dns-dnssec-keydata", kwargs={"pk": self.domain_dsdata.id}) + ) + self.assertContains(page, "Warning, you cannot add Key Data") - def test_domain_overview_blocked_for_ineligible_user(self): - """We could easily duplicate this test for all domain management - views, but a single url test should be solid enough since all domain - management pages share the same permissions class""" - self.user.status = User.RESTRICTED - self.user.save() - home_page = self.app.get("/") - self.assertContains(home_page, "igorville.gov") - with less_console_noise(): - response = self.client.get(reverse("domain", kwargs={"pk": self.domain.id})) - self.assertEqual(response.status_code, 403) + + class TestApplicationStatus(TestWithUser, WebTest):