diff --git a/src/registrar/templates/includes/summary_item.html b/src/registrar/templates/includes/summary_item.html
index 7c0d801ad..a2f328e1f 100644
--- a/src/registrar/templates/includes/summary_item.html
+++ b/src/registrar/templates/includes/summary_item.html
@@ -21,6 +21,9 @@
{% else %}
{% endif %}
+ {% if sub_header_text %}
+
+ {% endif %}
{% if address %}
{% include "includes/organization_address.html" with organization=value %}
{% elif contact %}
@@ -39,6 +42,10 @@
{% endfor %}
+ {% elif custom_text_for_value_none %}
+
+ {{ custom_text_for_value_none }}
+
{% else %}
None
@@ -92,6 +99,8 @@
{% if value %}
{{ value }}
+ {% elif custom_text_for_value_none %}
+ {{ custom_text_for_value_none }}
{% else %}
None
{% endif %}
diff --git a/src/registrar/tests/common.py b/src/registrar/tests/common.py
index 6dd88c1c1..c2f11b85d 100644
--- a/src/registrar/tests/common.py
+++ b/src/registrar/tests/common.py
@@ -789,6 +789,7 @@ def create_ready_domain():
return domain
+# TODO in 1793: Remove the federal agency/updated federal agency fields
def completed_domain_request(
has_other_contacts=True,
has_current_website=True,
@@ -803,6 +804,8 @@ def completed_domain_request(
generic_org_type="federal",
is_election_board=False,
organization_type=None,
+ federal_agency=None,
+ updated_federal_agency=None,
):
"""A completed domain request."""
if not user:
@@ -839,6 +842,7 @@ def completed_domain_request(
last_name="Bob",
is_staff=True,
)
+
domain_request_kwargs = dict(
generic_org_type=generic_org_type,
is_election_board=is_election_board,
@@ -856,6 +860,8 @@ def completed_domain_request(
creator=user,
status=status,
investigator=investigator,
+ federal_agency=federal_agency,
+ updated_federal_agency=updated_federal_agency,
)
if has_about_your_organization:
domain_request_kwargs["about_your_organization"] = "e-Government"
@@ -864,7 +870,6 @@ def completed_domain_request(
if organization_type:
domain_request_kwargs["organization_type"] = organization_type
-
domain_request, _ = DomainRequest.objects.get_or_create(**domain_request_kwargs)
if has_other_contacts:
diff --git a/src/registrar/tests/test_admin.py b/src/registrar/tests/test_admin.py
index bca1a94cb..cf00994be 100644
--- a/src/registrar/tests/test_admin.py
+++ b/src/registrar/tests/test_admin.py
@@ -18,6 +18,7 @@ from registrar.admin import (
AuditedAdmin,
ContactAdmin,
DomainInformationAdmin,
+ MyHostAdmin,
UserDomainRoleAdmin,
VerifiedByStaffAdmin,
)
@@ -76,6 +77,13 @@ class TestDomainAdmin(MockEppLib, WebTest):
self.app.set_user(self.superuser.username)
self.client.force_login(self.superuser)
+ # Add domain data
+ self.ready_domain, _ = Domain.objects.get_or_create(name="fakeready.gov", state=Domain.State.READY)
+ self.unknown_domain, _ = Domain.objects.get_or_create(name="fakeunknown.gov", state=Domain.State.UNKNOWN)
+ self.dns_domain, _ = Domain.objects.get_or_create(name="fakedns.gov", state=Domain.State.DNS_NEEDED)
+ self.hold_domain, _ = Domain.objects.get_or_create(name="fakehold.gov", state=Domain.State.ON_HOLD)
+ self.deleted_domain, _ = Domain.objects.get_or_create(name="fakedeleted.gov", state=Domain.State.DELETED)
+
# Contains some test tools
self.test_helper = GenericTestHelper(
factory=self.factory,
@@ -159,6 +167,68 @@ class TestDomainAdmin(MockEppLib, WebTest):
# Test for the copy link
self.assertContains(response, "usa-button__clipboard")
+ @less_console_noise_decorator
+ def test_helper_text(self):
+ """
+ Tests for the correct helper text on this page
+ """
+
+ # Create a ready domain with a preset expiration date
+ domain, _ = Domain.objects.get_or_create(name="fake.gov", state=Domain.State.READY)
+
+ p = "adminpass"
+ self.client.login(username="superuser", password=p)
+ response = self.client.get(
+ "/admin/registrar/domain/{}/change/".format(domain.pk),
+ follow=True,
+ )
+
+ # Make sure the page loaded, and that we're on the right page
+ self.assertEqual(response.status_code, 200)
+ self.assertContains(response, domain.name)
+
+ # These should exist in the response
+ expected_values = [
+ ("expiration_date", "Date the domain expires in the registry"),
+ ("first_ready_at", 'Date when this domain first moved into "ready" state; date will never change'),
+ ("deleted_at", 'Will appear blank unless the domain is in "deleted" state'),
+ ]
+ self.test_helper.assert_response_contains_distinct_values(response, expected_values)
+
+ @less_console_noise_decorator
+ def test_helper_text_state(self):
+ """
+ Tests for the correct state helper text on this page
+ """
+
+ # We don't need to check for all text content, just a portion of it
+ expected_unknown_domain_message = "The creator of the associated domain request has not logged in to"
+ expected_dns_message = "Before this domain can be used, name server addresses need"
+ expected_hold_message = "While on hold, this domain"
+ expected_deleted_message = "This domain was permanently removed from the registry."
+ expected_messages = [
+ (self.ready_domain, "This domain has name servers and is ready for use."),
+ (self.unknown_domain, expected_unknown_domain_message),
+ (self.dns_domain, expected_dns_message),
+ (self.hold_domain, expected_hold_message),
+ (self.deleted_domain, expected_deleted_message),
+ ]
+
+ p = "adminpass"
+ self.client.login(username="superuser", password=p)
+ for domain, message in expected_messages:
+ with self.subTest(domain_state=domain.state):
+ response = self.client.get(
+ "/admin/registrar/domain/{}/change/".format(domain.id),
+ )
+
+ # Make sure the page loaded, and that we're on the right page
+ self.assertEqual(response.status_code, 200)
+ self.assertContains(response, domain.name)
+
+ # Check that the right help text exists
+ self.assertContains(response, message)
+
@patch("registrar.admin.DomainAdmin._get_current_date", return_value=date(2024, 1, 1))
def test_extend_expiration_date_button(self, mock_date_today):
"""
@@ -782,6 +852,152 @@ class TestDomainRequestAdmin(MockEppLib):
)
self.mock_client = MockSESClient()
+ @less_console_noise_decorator
+ def test_helper_text(self):
+ """
+ Tests for the correct helper text on this page
+ """
+
+ # Create a fake domain request and domain
+ domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.IN_REVIEW)
+
+ p = "adminpass"
+ self.client.login(username="superuser", password=p)
+ response = self.client.get(
+ "/admin/registrar/domainrequest/{}/change/".format(domain_request.pk),
+ follow=True,
+ )
+
+ # Make sure the page loaded, and that we're on the right page
+ self.assertEqual(response.status_code, 200)
+ self.assertContains(response, domain_request.requested_domain.name)
+
+ # These should exist in the response
+ expected_values = [
+ ("creator", "Person who submitted the domain request; will not receive email updates"),
+ (
+ "submitter",
+ 'Person listed under "your contact information" in the request form; will receive email updates',
+ ),
+ ("approved_domain", "Domain associated with this request; will be blank until request is approved"),
+ ("no_other_contacts_rationale", "Required if creator does not list other employees"),
+ ("alternative_domains", "Other domain names the creator provided for consideration"),
+ ("no_other_contacts_rationale", "Required if creator does not list other employees"),
+ ("Urbanization", "Required for Puerto Rico only"),
+ ]
+ self.test_helper.assert_response_contains_distinct_values(response, expected_values)
+
+ @less_console_noise_decorator
+ def test_status_logs(self):
+ """
+ Tests that the status changes are shown in a table on the domain request change form,
+ accurately and in chronological order.
+ """
+
+ # Create a fake domain request and domain
+ domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.STARTED)
+
+ p = "adminpass"
+ self.client.login(username="superuser", password=p)
+ response = self.client.get(
+ "/admin/registrar/domainrequest/{}/change/".format(domain_request.pk),
+ follow=True,
+ )
+
+ # Make sure the page loaded, and that we're on the right page
+ self.assertEqual(response.status_code, 200)
+ self.assertContains(response, domain_request.requested_domain.name)
+
+ # Table will contain one row for Started
+ self.assertContains(response, "
Started | ", count=1)
+ self.assertNotContains(response, "Submitted | ")
+
+ domain_request.submit()
+ domain_request.save()
+
+ response = self.client.get(
+ "/admin/registrar/domainrequest/{}/change/".format(domain_request.pk),
+ follow=True,
+ )
+
+ # Table will contain and extra row for Submitted
+ self.assertContains(response, "Started | ", count=1)
+ self.assertContains(response, "Submitted | ", count=1)
+
+ domain_request.in_review()
+ domain_request.save()
+
+ response = self.client.get(
+ "/admin/registrar/domainrequest/{}/change/".format(domain_request.pk),
+ follow=True,
+ )
+
+ # Table will contain and extra row for In review
+ self.assertContains(response, "Started | ", count=1)
+ self.assertContains(response, "Submitted | ", count=1)
+ self.assertContains(response, "In review | ", count=1)
+
+ domain_request.action_needed()
+ domain_request.save()
+
+ response = self.client.get(
+ "/admin/registrar/domainrequest/{}/change/".format(domain_request.pk),
+ follow=True,
+ )
+
+ # Table will contain and extra row for Action needed
+ self.assertContains(response, "Started | ", count=1)
+ self.assertContains(response, "Submitted | ", count=1)
+ self.assertContains(response, "In review | ", count=1)
+ self.assertContains(response, "Action needed | ", count=1)
+
+ domain_request.in_review()
+ domain_request.save()
+
+ response = self.client.get(
+ "/admin/registrar/domainrequest/{}/change/".format(domain_request.pk),
+ follow=True,
+ )
+
+ # Define the expected sequence of status changes
+ expected_status_changes = [
+ "In review | ",
+ "Action needed | ",
+ "In review | ",
+ "Submitted | ",
+ "Started | ",
+ ]
+
+ # Test for the order of status changes
+ for status_change in expected_status_changes:
+ self.assertContains(response, status_change, html=True)
+
+ # Table now contains 2 rows for Approved
+ self.assertContains(response, "Started | ", count=1)
+ self.assertContains(response, "Submitted | ", count=1)
+ self.assertContains(response, "In review | ", count=2)
+ self.assertContains(response, "Action needed | ", count=1)
+
+ def test_collaspe_toggle_button_markup(self):
+ """
+ Tests for the correct collapse toggle button markup
+ """
+
+ # Create a fake domain request and domain
+ domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.IN_REVIEW)
+
+ p = "adminpass"
+ self.client.login(username="superuser", password=p)
+ response = self.client.get(
+ "/admin/registrar/domainrequest/{}/change/".format(domain_request.pk),
+ follow=True,
+ )
+
+ # Make sure the page loaded, and that we're on the right page
+ self.assertEqual(response.status_code, 200)
+ self.assertContains(response, domain_request.requested_domain.name)
+ self.test_helper.assertContains(response, "Show details")
+
@less_console_noise_decorator
def test_analyst_can_see_and_edit_alternative_domain(self):
"""Tests if an analyst can still see and edit the alternative domain field"""
@@ -1889,6 +2105,9 @@ class TestDomainRequestAdmin(MockEppLib):
"purpose",
"no_other_contacts_rationale",
"anything_else",
+ "has_anything_else_text",
+ "cisa_representative_email",
+ "has_cisa_representative",
"is_policy_acknowledged",
"submission_date",
"notes",
@@ -1920,6 +2139,7 @@ class TestDomainRequestAdmin(MockEppLib):
"no_other_contacts_rationale",
"anything_else",
"is_policy_acknowledged",
+ "cisa_representative_email",
]
self.assertEqual(readonly_fields, expected_fields)
@@ -2315,6 +2535,54 @@ class DomainInvitationAdminTest(TestCase):
self.assertContains(response, retrieved_html, count=1)
+class TestHostAdmin(TestCase):
+ def setUp(self):
+ """Setup environment for a mock admin user"""
+ super().setUp()
+ self.site = AdminSite()
+ self.factory = RequestFactory()
+ self.admin = MyHostAdmin(model=Host, admin_site=self.site)
+ self.client = Client(HTTP_HOST="localhost:8080")
+ self.superuser = create_superuser()
+ self.test_helper = GenericTestHelper(
+ factory=self.factory,
+ user=self.superuser,
+ admin=self.admin,
+ url="/admin/registrar/Host/",
+ model=Host,
+ )
+
+ def tearDown(self):
+ super().tearDown()
+ Host.objects.all().delete()
+ Domain.objects.all().delete()
+
+ @less_console_noise_decorator
+ def test_helper_text(self):
+ """
+ Tests for the correct helper text on this page
+ """
+ domain, _ = Domain.objects.get_or_create(name="fake.gov", state=Domain.State.READY)
+ # Create a fake host
+ host, _ = Host.objects.get_or_create(name="ns1.test.gov", domain=domain)
+
+ p = "adminpass"
+ self.client.login(username="superuser", password=p)
+ response = self.client.get(
+ "/admin/registrar/host/{}/change/".format(host.pk),
+ follow=True,
+ )
+
+ # Make sure the page loaded
+ self.assertEqual(response.status_code, 200)
+
+ # These should exist in the response
+ expected_values = [
+ ("domain", "Domain associated with this host"),
+ ]
+ self.test_helper.assert_response_contains_distinct_values(response, expected_values)
+
+
class TestDomainInformationAdmin(TestCase):
def setUp(self):
"""Setup environment for a mock admin user"""
@@ -2367,6 +2635,38 @@ class TestDomainInformationAdmin(TestCase):
Contact.objects.all().delete()
User.objects.all().delete()
+ @less_console_noise_decorator
+ def test_helper_text(self):
+ """
+ Tests for the correct helper text on this page
+ """
+
+ # Create a fake domain request and domain
+ domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.IN_REVIEW)
+ domain_request.approve()
+ domain_info = DomainInformation.objects.filter(domain=domain_request.approved_domain).get()
+
+ p = "adminpass"
+ self.client.login(username="superuser", password=p)
+ response = self.client.get(
+ "/admin/registrar/domaininformation/{}/change/".format(domain_info.pk),
+ follow=True,
+ )
+
+ # Make sure the page loaded, and that we're on the right page
+ self.assertEqual(response.status_code, 200)
+ self.assertContains(response, domain_info.domain.name)
+
+ # These should exist in the response
+ expected_values = [
+ ("creator", "Person who submitted the domain request"),
+ ("submitter", 'Person listed under "your contact information" in the request form'),
+ ("domain_request", "Request associated with this domain"),
+ ("no_other_contacts_rationale", "Required if creator does not list other employees"),
+ ("urbanization", "Required for Puerto Rico only"),
+ ]
+ self.test_helper.assert_response_contains_distinct_values(response, expected_values)
+
@less_console_noise_decorator
def test_other_contacts_has_readonly_link(self):
"""Tests if the readonly other_contacts field has links"""
@@ -2711,7 +3011,7 @@ class UserDomainRoleAdminTest(TestCase):
self.assertContains(response, "Joe Jones AntarcticPolarBears@example.com", count=1)
-class ListHeaderAdminTest(TestCase):
+class TestListHeaderAdmin(TestCase):
def setUp(self):
self.site = AdminSite()
self.factory = RequestFactory()
@@ -2784,10 +3084,43 @@ class ListHeaderAdminTest(TestCase):
User.objects.all().delete()
-class MyUserAdminTest(TestCase):
+class TestMyUserAdmin(TestCase):
def setUp(self):
admin_site = AdminSite()
self.admin = MyUserAdmin(model=get_user_model(), admin_site=admin_site)
+ self.client = Client(HTTP_HOST="localhost:8080")
+ self.superuser = create_superuser()
+ self.test_helper = GenericTestHelper(admin=self.admin)
+
+ def tearDown(self):
+ super().tearDown()
+ User.objects.all().delete()
+
+ @less_console_noise_decorator
+ def test_helper_text(self):
+ """
+ Tests for the correct helper text on this page
+ """
+ user = create_user()
+
+ p = "adminpass"
+ self.client.login(username="superuser", password=p)
+ response = self.client.get(
+ "/admin/registrar/user/{}/change/".format(user.pk),
+ follow=True,
+ )
+
+ # Make sure the page loaded
+ self.assertEqual(response.status_code, 200)
+
+ # These should exist in the response
+ expected_values = [
+ ("password", "Raw passwords are not stored, so they will not display here."),
+ ("status", 'Users in "restricted" status cannot make updates in the registrar or start a new request.'),
+ ("is_staff", "Designates whether the user can log in to this admin site"),
+ ("is_superuser", "For development purposes only; provides superuser access on the database level"),
+ ]
+ self.test_helper.assert_response_contains_distinct_values(response, expected_values)
def test_list_display_without_username(self):
with less_console_noise():
@@ -2809,8 +3142,9 @@ class MyUserAdminTest(TestCase):
def test_get_fieldsets_superuser(self):
with less_console_noise():
request = self.client.request().wsgi_request
- request.user = create_superuser()
+ request.user = self.superuser
fieldsets = self.admin.get_fieldsets(request)
+
expected_fieldsets = super(MyUserAdmin, self.admin).get_fieldsets(request)
self.assertEqual(fieldsets, expected_fieldsets)
@@ -2820,16 +3154,21 @@ class MyUserAdminTest(TestCase):
request.user = create_user()
fieldsets = self.admin.get_fieldsets(request)
expected_fieldsets = (
- (None, {"fields": ("password", "status")}),
+ (
+ None,
+ {
+ "fields": (
+ "status",
+ "verification_type",
+ )
+ },
+ ),
("Personal Info", {"fields": ("first_name", "last_name", "email")}),
("Permissions", {"fields": ("is_active", "groups")}),
("Important dates", {"fields": ("last_login", "date_joined")}),
)
self.assertEqual(fieldsets, expected_fieldsets)
- def tearDown(self):
- User.objects.all().delete()
-
class AuditedAdminTest(TestCase):
def setUp(self):
@@ -3303,10 +3642,43 @@ class ContactAdminTest(TestCase):
User.objects.all().delete()
-class VerifiedByStaffAdminTestCase(TestCase):
+class TestVerifiedByStaffAdmin(TestCase):
def setUp(self):
+ super().setUp()
+ self.site = AdminSite()
self.superuser = create_superuser()
+ self.admin = VerifiedByStaffAdmin(model=VerifiedByStaff, admin_site=self.site)
self.factory = RequestFactory()
+ self.client = Client(HTTP_HOST="localhost:8080")
+ self.test_helper = GenericTestHelper(admin=self.admin)
+
+ def tearDown(self):
+ super().tearDown()
+ VerifiedByStaff.objects.all().delete()
+ User.objects.all().delete()
+
+ @less_console_noise_decorator
+ def test_helper_text(self):
+ """
+ Tests for the correct helper text on this page
+ """
+ vip_instance, _ = VerifiedByStaff.objects.get_or_create(email="test@example.com", notes="Test Notes")
+
+ p = "adminpass"
+ self.client.login(username="superuser", password=p)
+ response = self.client.get(
+ "/admin/registrar/verifiedbystaff/{}/change/".format(vip_instance.pk),
+ follow=True,
+ )
+
+ # Make sure the page loaded
+ self.assertEqual(response.status_code, 200)
+
+ # These should exist in the response
+ expected_values = [
+ ("requestor", "Person who verified this user"),
+ ]
+ self.test_helper.assert_response_contains_distinct_values(response, expected_values)
def test_save_model_sets_user_field(self):
with less_console_noise():
diff --git a/src/registrar/tests/test_forms.py b/src/registrar/tests/test_forms.py
index 4b8904f0c..c72c70e98 100644
--- a/src/registrar/tests/test_forms.py
+++ b/src/registrar/tests/test_forms.py
@@ -15,7 +15,7 @@ from registrar.forms.domain_request_wizard import (
RequirementsForm,
TribalGovernmentForm,
PurposeForm,
- AnythingElseForm,
+ AdditionalDetailsForm,
AboutYourOrganizationForm,
)
from registrar.forms.domain import ContactForm
@@ -274,7 +274,7 @@ class TestFormValidation(MockEppLib):
def test_anything_else_form_about_your_organization_character_count_invalid(self):
"""Response must be less than 2000 characters."""
- form = AnythingElseForm(
+ form = AdditionalDetailsForm(
data={
"anything_else": "Bacon ipsum dolor amet fatback strip steak pastrami"
"shankle, drumstick doner chicken landjaeger turkey andouille."
diff --git a/src/registrar/tests/test_management_scripts.py b/src/registrar/tests/test_management_scripts.py
index 26161b272..86ea1847f 100644
--- a/src/registrar/tests/test_management_scripts.py
+++ b/src/registrar/tests/test_management_scripts.py
@@ -14,8 +14,9 @@ from registrar.models import (
TransitionDomain,
DomainInformation,
UserDomainRole,
+ VerifiedByStaff,
+ PublicContact,
)
-from registrar.models.public_contact import PublicContact
from django.core.management import call_command
from unittest.mock import patch, call
@@ -25,6 +26,103 @@ from .common import MockEppLib, less_console_noise, completed_domain_request
from api.tests.common import less_console_noise_decorator
+class TestPopulateVerificationType(MockEppLib):
+ """Tests for the populate_organization_type script"""
+
+ def setUp(self):
+ """Creates a fake domain object"""
+ super().setUp()
+
+ # Get the domain requests
+ self.domain_request_1 = completed_domain_request(
+ name="lasers.gov",
+ generic_org_type=DomainRequest.OrganizationChoices.FEDERAL,
+ is_election_board=True,
+ status=DomainRequest.DomainRequestStatus.IN_REVIEW,
+ )
+
+ # Approve the request
+ self.domain_request_1.approve()
+
+ # Get the domains
+ self.domain_1 = Domain.objects.get(name="lasers.gov")
+
+ # Get users
+ self.regular_user, _ = User.objects.get_or_create(username="testuser@igormail.gov")
+
+ vip, _ = VerifiedByStaff.objects.get_or_create(email="vipuser@igormail.gov")
+ self.verified_by_staff_user, _ = User.objects.get_or_create(username="vipuser@igormail.gov")
+
+ grandfathered, _ = TransitionDomain.objects.get_or_create(
+ username="grandpa@igormail.gov", domain_name=self.domain_1.name
+ )
+ self.grandfathered_user, _ = User.objects.get_or_create(username="grandpa@igormail.gov")
+
+ invited, _ = DomainInvitation.objects.get_or_create(
+ email="invited@igormail.gov", domain=self.domain_1, status=DomainInvitation.DomainInvitationStatus.RETRIEVED
+ )
+ self.invited_user, _ = User.objects.get_or_create(username="invited@igormail.gov")
+
+ self.untouched_user, _ = User.objects.get_or_create(
+ username="iaminvincible@igormail.gov", verification_type=User.VerificationTypeChoices.GRANDFATHERED
+ )
+
+ # Fixture users should be untouched by the script. These will auto update once the
+ # user logs in / creates an account.
+ self.fixture_user, _ = User.objects.get_or_create(
+ username="fixture@igormail.gov", verification_type=User.VerificationTypeChoices.FIXTURE_USER
+ )
+
+ def tearDown(self):
+ """Deletes all DB objects related to migrations"""
+ super().tearDown()
+
+ # Delete domains and related information
+ Domain.objects.all().delete()
+ DomainInformation.objects.all().delete()
+ DomainRequest.objects.all().delete()
+ User.objects.all().delete()
+ Contact.objects.all().delete()
+ Website.objects.all().delete()
+
+ @less_console_noise_decorator
+ def run_populate_verification_type(self):
+ """
+ This method executes the populate_organization_type command.
+
+ The 'call_command' function from Django's management framework is then used to
+ execute the populate_organization_type command with the specified arguments.
+ """
+ with patch(
+ "registrar.management.commands.utility.terminal_helper.TerminalHelper.query_yes_no_exit", # noqa
+ return_value=True,
+ ):
+ call_command("populate_verification_type")
+
+ @less_console_noise_decorator
+ def test_verification_type_script_populates_data(self):
+ """Ensures that the verification type script actually populates data"""
+
+ # Run the script
+ self.run_populate_verification_type()
+
+ # Scripts don't work as we'd expect in our test environment, we need to manually
+ # trigger the refresh event
+ self.regular_user.refresh_from_db()
+ self.grandfathered_user.refresh_from_db()
+ self.invited_user.refresh_from_db()
+ self.verified_by_staff_user.refresh_from_db()
+ self.untouched_user.refresh_from_db()
+
+ # Test all users
+ self.assertEqual(self.regular_user.verification_type, User.VerificationTypeChoices.REGULAR)
+ self.assertEqual(self.grandfathered_user.verification_type, User.VerificationTypeChoices.GRANDFATHERED)
+ self.assertEqual(self.invited_user.verification_type, User.VerificationTypeChoices.INVITED)
+ self.assertEqual(self.verified_by_staff_user.verification_type, User.VerificationTypeChoices.VERIFIED_BY_STAFF)
+ self.assertEqual(self.untouched_user.verification_type, User.VerificationTypeChoices.GRANDFATHERED)
+ self.assertEqual(self.fixture_user.verification_type, User.VerificationTypeChoices.FIXTURE_USER)
+
+
class TestPopulateOrganizationType(MockEppLib):
"""Tests for the populate_organization_type script"""
@@ -743,3 +841,120 @@ class TestDiscloseEmails(MockEppLib):
)
]
)
+
+
+# TODO in #1793: Remove this whole test class
+class TestPopulateDomainUpdatedFederalAgency(TestCase):
+ def setUp(self):
+ super().setUp()
+
+ # Get the domain requests
+ self.domain_request_1 = completed_domain_request(
+ name="stitches.gov",
+ generic_org_type=DomainRequest.OrganizationChoices.FEDERAL,
+ is_election_board=True,
+ status=DomainRequest.DomainRequestStatus.IN_REVIEW,
+ federal_agency="U.S. Peace Corps",
+ )
+ self.domain_request_2 = completed_domain_request(
+ name="fadoesntexist.gov",
+ generic_org_type=DomainRequest.OrganizationChoices.FEDERAL,
+ is_election_board=True,
+ status=DomainRequest.DomainRequestStatus.IN_REVIEW,
+ federal_agency="MEOWARDRULES",
+ )
+ self.domain_request_3 = completed_domain_request(
+ name="nullfederalagency.gov",
+ generic_org_type=DomainRequest.OrganizationChoices.FEDERAL,
+ is_election_board=True,
+ status=DomainRequest.DomainRequestStatus.IN_REVIEW,
+ federal_agency=None,
+ )
+
+ # Approve all three requests
+ self.domain_request_1.approve()
+ self.domain_request_2.approve()
+ self.domain_request_3.approve()
+
+ # Get the domains
+ self.domain_1 = Domain.objects.get(name="stitches.gov")
+ self.domain_2 = Domain.objects.get(name="fadoesntexist.gov")
+ self.domain_3 = Domain.objects.get(name="nullfederalagency.gov")
+
+ # Get the domain infos
+ self.domain_info_1 = DomainInformation.objects.get(domain=self.domain_1)
+ self.domain_info_2 = DomainInformation.objects.get(domain=self.domain_2)
+ self.domain_info_3 = DomainInformation.objects.get(domain=self.domain_3)
+
+ def tearDown(self):
+ super().tearDown()
+ DomainInformation.objects.all().delete()
+ DomainRequest.objects.all().delete()
+ Domain.objects.all().delete()
+
+ def run_populate_domain_updated_federal_agency(self):
+ """
+ This method executes the populate_domain_updated_federal_agency command.
+
+ The 'call_command' function from Django's management framework is then used to
+ execute the populate_domain_updated_federal_agency command.
+ """
+ with less_console_noise():
+ call_command("populate_domain_updated_federal_agency")
+
+ def test_domain_information_renaming_federal_agency_success(self):
+ """
+ Domain Information updates successfully for an "outdated" Federal Agency
+ """
+
+ self.run_populate_domain_updated_federal_agency()
+
+ self.domain_info_1.refresh_from_db()
+
+ previous_federal_agency_name = self.domain_info_1.federal_agency
+
+ updated_federal_agency_name = self.domain_info_1.updated_federal_agency.agency
+
+ self.assertEqual(previous_federal_agency_name, "U.S. Peace Corps")
+ self.assertEqual(updated_federal_agency_name, "Peace Corps")
+
+ def test_domain_information_does_not_exist(self):
+ """
+ Update a Federal Agency that doesn't exist
+ (should return None bc the Federal Agency didn't exist before)
+ """
+
+ self.run_populate_domain_updated_federal_agency()
+
+ self.domain_info_2.refresh_from_db()
+
+ self.assertEqual(self.domain_info_2.updated_federal_agency, None)
+
+ def test_domain_request_is_skipped(self):
+ """
+ Update a Domain Request that doesn't exist
+ (should return None bc the Federal Agency didn't exist before)
+ """
+
+ # Test case #2
+ self.run_populate_domain_updated_federal_agency()
+
+ self.domain_request_2.refresh_from_db()
+
+ self.assertEqual(self.domain_request_2.updated_federal_agency, None)
+
+ def test_domain_information_updating_null_federal_agency_to_non_federal_agency(self):
+ """
+ Updating a Domain Information that was previously None
+ to Non-Federal Agency
+ """
+
+ self.run_populate_domain_updated_federal_agency()
+
+ self.domain_info_3.refresh_from_db()
+
+ previous_federal_agency_name = self.domain_info_3.federal_agency
+ updated_federal_agency_name = self.domain_info_3.updated_federal_agency.agency
+
+ self.assertEqual(previous_federal_agency_name, None)
+ self.assertEqual(updated_federal_agency_name, "Non-Federal Agency")
diff --git a/src/registrar/tests/test_views.py b/src/registrar/tests/test_views.py
index b8055f288..217e24b9a 100644
--- a/src/registrar/tests/test_views.py
+++ b/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)
diff --git a/src/registrar/tests/test_views_domain.py b/src/registrar/tests/test_views_domain.py
index fc391f8b5..6448e91e1 100644
--- a/src/registrar/tests/test_views_domain.py
+++ b/src/registrar/tests/test_views_domain.py
@@ -344,8 +344,6 @@ class TestDomainManagers(TestDomainOverview):
def tearDown(self):
"""Ensure that the user has its original permissions"""
super().tearDown()
- self.user.is_staff = False
- self.user.save()
def test_domain_managers(self):
response = self.client.get(reverse("domain-users", kwargs={"pk": self.domain.id}))
diff --git a/src/registrar/tests/test_views_request.py b/src/registrar/tests/test_views_request.py
index a4cb210bc..22ad56646 100644
--- a/src/registrar/tests/test_views_request.py
+++ b/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
@@ -356,33 +354,39 @@ class DomainRequestTests(TestWithUser, WebTest):
# the post request should return a redirect to the next form in
# the domain request page
self.assertEqual(other_contacts_result.status_code, 302)
- self.assertEqual(other_contacts_result["Location"], "/request/anything_else/")
+ self.assertEqual(other_contacts_result["Location"], "/request/additional_details/")
num_pages_tested += 1
- # ---- ANYTHING ELSE PAGE ----
+ # ---- ADDITIONAL DETAILS PAGE ----
# Follow the redirect to the next form page
self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
- anything_else_page = other_contacts_result.follow()
- anything_else_form = anything_else_page.forms[0]
+ additional_details_page = other_contacts_result.follow()
+ additional_details_form = additional_details_page.forms[0]
- anything_else_form["anything_else-anything_else"] = "Nothing else."
+ # load inputs with test data
+
+ additional_details_form["additional_details-has_cisa_representative"] = "True"
+ additional_details_form["additional_details-has_anything_else_text"] = "True"
+ additional_details_form["additional_details-cisa_representative_email"] = "FakeEmail@gmail.com"
+ additional_details_form["additional_details-anything_else"] = "Nothing else."
# test next button
self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
- anything_else_result = anything_else_form.submit()
+ additional_details_result = additional_details_form.submit()
# validate that data from this step are being saved
domain_request = DomainRequest.objects.get() # there's only one
+ self.assertEqual(domain_request.cisa_representative_email, "FakeEmail@gmail.com")
self.assertEqual(domain_request.anything_else, "Nothing else.")
# the post request should return a redirect to the next form in
# the domain request page
- self.assertEqual(anything_else_result.status_code, 302)
- self.assertEqual(anything_else_result["Location"], "/request/requirements/")
+ self.assertEqual(additional_details_result.status_code, 302)
+ self.assertEqual(additional_details_result["Location"], "/request/requirements/")
num_pages_tested += 1
# ---- REQUIREMENTS PAGE ----
# Follow the redirect to the next form page
self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
- requirements_page = anything_else_result.follow()
+ requirements_page = additional_details_result.follow()
requirements_form = requirements_page.forms[0]
requirements_form["requirements-is_policy_acknowledged"] = True
@@ -434,6 +438,7 @@ class DomainRequestTests(TestWithUser, WebTest):
self.assertContains(review_page, "Another Tester")
self.assertContains(review_page, "testy2@town.com")
self.assertContains(review_page, "(201) 555-5557")
+ self.assertContains(review_page, "FakeEmail@gmail.com")
self.assertContains(review_page, "Nothing else.")
# We can't test the modal itself as it relies on JS for init and triggering,
@@ -717,13 +722,25 @@ class DomainRequestTests(TestWithUser, WebTest):
self.assertContains(contact_page, self.TITLES[Step.ABOUT_YOUR_ORGANIZATION])
- def test_yes_no_form_inits_blank_for_new_domain_request(self):
+ def test_yes_no_contact_form_inits_blank_for_new_domain_request(self):
"""On the Other Contacts page, the yes/no form gets initialized with nothing selected for
new domain requests"""
other_contacts_page = self.app.get(reverse("domain-request:other_contacts"))
other_contacts_form = other_contacts_page.forms[0]
self.assertEquals(other_contacts_form["other_contacts-has_other_contacts"].value, None)
+ def test_yes_no_additional_form_inits_blank_for_new_domain_request(self):
+ """On the Additional Details page, the yes/no form gets initialized with nothing selected for
+ new domain requests"""
+ additional_details_page = self.app.get(reverse("domain-request:additional_details"))
+ additional_form = additional_details_page.forms[0]
+
+ # Check the cisa representative yes/no field
+ self.assertEquals(additional_form["additional_details-has_cisa_representative"].value, None)
+
+ # Check the anything else yes/no field
+ self.assertEquals(additional_form["additional_details-has_anything_else_text"].value, None)
+
def test_yes_no_form_inits_yes_for_domain_request_with_other_contacts(self):
"""On the Other Contacts page, the yes/no form gets initialized with YES selected if the
domain request has other contacts"""
@@ -744,6 +761,38 @@ class DomainRequestTests(TestWithUser, WebTest):
other_contacts_form = other_contacts_page.forms[0]
self.assertEquals(other_contacts_form["other_contacts-has_other_contacts"].value, "True")
+ def test_yes_no_form_inits_yes_for_cisa_representative_and_anything_else(self):
+ """On the Additional Details page, the yes/no form gets initialized with YES selected
+ for both yes/no radios if the domain request has a value for cisa_representative and
+ anything_else"""
+
+ domain_request = completed_domain_request(user=self.user, has_anything_else=True)
+ domain_request.cisa_representative_email = "test@igorville.gov"
+ domain_request.anything_else = "1234"
+ domain_request.save()
+
+ # prime the form by visiting /edit
+ self.app.get(reverse("edit-domain-request", kwargs={"id": domain_request.pk}))
+ # django-webtest does not handle cookie-based sessions well because it keeps
+ # resetting the session key on each new request, thus destroying the concept
+ # of a "session". We are going to do it manually, saving the session ID here
+ # and then setting the cookie on each request.
+ session_id = self.app.cookies[settings.SESSION_COOKIE_NAME]
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+
+ additional_details_page = self.app.get(reverse("domain-request:additional_details"))
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+
+ additional_details_form = additional_details_page.forms[0]
+
+ # Check the cisa representative yes/no field
+ yes_no_cisa = additional_details_form["additional_details-has_cisa_representative"].value
+ self.assertEquals(yes_no_cisa, "True")
+
+ # Check the anything else yes/no field
+ yes_no_anything_else = additional_details_form["additional_details-has_anything_else_text"].value
+ self.assertEquals(yes_no_anything_else, "True")
+
def test_yes_no_form_inits_no_for_domain_request_with_no_other_contacts_rationale(self):
"""On the Other Contacts page, the yes/no form gets initialized with NO selected if the
domain request has no other contacts"""
@@ -766,6 +815,230 @@ class DomainRequestTests(TestWithUser, WebTest):
other_contacts_form = other_contacts_page.forms[0]
self.assertEquals(other_contacts_form["other_contacts-has_other_contacts"].value, "False")
+ def test_yes_no_form_for_domain_request_with_no_cisa_representative_and_anything_else(self):
+ """On the Additional details page, the form preselects "no" when has_cisa_representative
+ and anything_else is no"""
+
+ domain_request = completed_domain_request(user=self.user, has_anything_else=False)
+
+ # Unlike the other contacts form, the no button is tracked with these boolean fields.
+ # This means that we should expect this to correlate with the no button.
+ domain_request.has_anything_else_text = False
+ domain_request.has_cisa_representative = False
+ domain_request.save()
+
+ # prime the form by visiting /edit
+ self.app.get(reverse("edit-domain-request", kwargs={"id": domain_request.pk}))
+ # django-webtest does not handle cookie-based sessions well because it keeps
+ # resetting the session key on each new request, thus destroying the concept
+ # of a "session". We are going to do it manually, saving the session ID here
+ # and then setting the cookie on each request.
+ session_id = self.app.cookies[settings.SESSION_COOKIE_NAME]
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+
+ additional_details_page = self.app.get(reverse("domain-request:additional_details"))
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+
+ additional_details_form = additional_details_page.forms[0]
+
+ # Check the cisa representative yes/no field
+ yes_no_cisa = additional_details_form["additional_details-has_cisa_representative"].value
+ self.assertEquals(yes_no_cisa, "False")
+
+ # Check the anything else yes/no field
+ yes_no_anything_else = additional_details_form["additional_details-has_anything_else_text"].value
+ self.assertEquals(yes_no_anything_else, "False")
+
+ def test_submitting_additional_details_deletes_cisa_representative_and_anything_else(self):
+ """When a user submits the Additional Details form with no selected for all fields,
+ the domain request's data gets wiped when submitted"""
+ domain_request = completed_domain_request(name="nocisareps.gov", user=self.user)
+ domain_request.cisa_representative_email = "fake@faketown.gov"
+ domain_request.save()
+
+ # Make sure we have the data we need for the test
+ self.assertEqual(domain_request.anything_else, "There is more")
+ self.assertEqual(domain_request.cisa_representative_email, "fake@faketown.gov")
+
+ # prime the form by visiting /edit
+ self.app.get(reverse("edit-domain-request", kwargs={"id": domain_request.pk}))
+ # django-webtest does not handle cookie-based sessions well because it keeps
+ # resetting the session key on each new request, thus destroying the concept
+ # of a "session". We are going to do it manually, saving the session ID here
+ # and then setting the cookie on each request.
+ session_id = self.app.cookies[settings.SESSION_COOKIE_NAME]
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+
+ additional_details_page = self.app.get(reverse("domain-request:additional_details"))
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+
+ additional_details_form = additional_details_page.forms[0]
+
+ # Check the cisa representative yes/no field
+ yes_no_cisa = additional_details_form["additional_details-has_cisa_representative"].value
+ self.assertEquals(yes_no_cisa, "True")
+
+ # Check the anything else yes/no field
+ yes_no_anything_else = additional_details_form["additional_details-has_anything_else_text"].value
+ self.assertEquals(yes_no_anything_else, "True")
+
+ # Set fields to false
+ additional_details_form["additional_details-has_cisa_representative"] = "False"
+ additional_details_form["additional_details-has_anything_else_text"] = "False"
+
+ # Submit the form
+ additional_details_form.submit()
+
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+
+ # Verify that the anything_else and cisa_representative have been deleted from the DB
+ domain_request = DomainRequest.objects.get(requested_domain__name="nocisareps.gov")
+
+ # Check that our data has been cleared
+ self.assertEqual(domain_request.anything_else, None)
+ self.assertEqual(domain_request.cisa_representative_email, None)
+
+ # Double check the yes/no fields
+ self.assertEqual(domain_request.has_anything_else_text, False)
+ self.assertEqual(domain_request.has_cisa_representative, False)
+
+ def test_submitting_additional_details_populates_cisa_representative_and_anything_else(self):
+ """When a user submits the Additional Details form,
+ the domain request's data gets submitted"""
+ domain_request = completed_domain_request(name="cisareps.gov", user=self.user, has_anything_else=False)
+
+ # Make sure we have the data we need for the test
+ self.assertEqual(domain_request.anything_else, None)
+ self.assertEqual(domain_request.cisa_representative_email, None)
+
+ # These fields should not be selected at all, since we haven't initialized the form yet
+ self.assertEqual(domain_request.has_anything_else_text, None)
+ self.assertEqual(domain_request.has_cisa_representative, None)
+
+ # prime the form by visiting /edit
+ self.app.get(reverse("edit-domain-request", kwargs={"id": domain_request.pk}))
+ # django-webtest does not handle cookie-based sessions well because it keeps
+ # resetting the session key on each new request, thus destroying the concept
+ # of a "session". We are going to do it manually, saving the session ID here
+ # and then setting the cookie on each request.
+ session_id = self.app.cookies[settings.SESSION_COOKIE_NAME]
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+
+ additional_details_page = self.app.get(reverse("domain-request:additional_details"))
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+
+ additional_details_form = additional_details_page.forms[0]
+
+ # Set fields to true, and set data on those fields
+ additional_details_form["additional_details-has_cisa_representative"] = "True"
+ additional_details_form["additional_details-has_anything_else_text"] = "True"
+ additional_details_form["additional_details-cisa_representative_email"] = "test@faketest.gov"
+ additional_details_form["additional_details-anything_else"] = "redandblue"
+
+ # Submit the form
+ additional_details_form.submit()
+
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+
+ # Verify that the anything_else and cisa_representative exist in the db
+ domain_request = DomainRequest.objects.get(requested_domain__name="cisareps.gov")
+
+ self.assertEqual(domain_request.anything_else, "redandblue")
+ self.assertEqual(domain_request.cisa_representative_email, "test@faketest.gov")
+
+ self.assertEqual(domain_request.has_cisa_representative, True)
+ self.assertEqual(domain_request.has_anything_else_text, True)
+
+ def test_if_cisa_representative_yes_no_form_is_yes_then_field_is_required(self):
+ """Applicants with a cisa representative must provide a value"""
+ domain_request = completed_domain_request(name="cisareps.gov", user=self.user, has_anything_else=False)
+
+ # prime the form by visiting /edit
+ self.app.get(reverse("edit-domain-request", kwargs={"id": domain_request.pk}))
+ # django-webtest does not handle cookie-based sessions well because it keeps
+ # resetting the session key on each new request, thus destroying the concept
+ # of a "session". We are going to do it manually, saving the session ID here
+ # and then setting the cookie on each request.
+ session_id = self.app.cookies[settings.SESSION_COOKIE_NAME]
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+
+ additional_details_page = self.app.get(reverse("domain-request:additional_details"))
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+
+ additional_details_form = additional_details_page.forms[0]
+
+ # Set fields to true, and set data on those fields
+ additional_details_form["additional_details-has_cisa_representative"] = "True"
+ additional_details_form["additional_details-has_anything_else_text"] = "False"
+
+ # Submit the form
+ response = additional_details_form.submit()
+
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+
+ self.assertContains(response, "Enter the email address of your CISA regional representative.")
+
+ def test_if_anything_else_yes_no_form_is_yes_then_field_is_required(self):
+ """Applicants with a anything else must provide a value"""
+ domain_request = completed_domain_request(name="cisareps.gov", user=self.user, has_anything_else=False)
+
+ # prime the form by visiting /edit
+ self.app.get(reverse("edit-domain-request", kwargs={"id": domain_request.pk}))
+ # django-webtest does not handle cookie-based sessions well because it keeps
+ # resetting the session key on each new request, thus destroying the concept
+ # of a "session". We are going to do it manually, saving the session ID here
+ # and then setting the cookie on each request.
+ session_id = self.app.cookies[settings.SESSION_COOKIE_NAME]
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+
+ additional_details_page = self.app.get(reverse("domain-request:additional_details"))
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+
+ additional_details_form = additional_details_page.forms[0]
+
+ # Set fields to true, and set data on those fields
+ additional_details_form["additional_details-has_cisa_representative"] = "False"
+ additional_details_form["additional_details-has_anything_else_text"] = "True"
+
+ # Submit the form
+ response = additional_details_form.submit()
+
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+
+ expected_message = "Provide additional details you’d like us to know. If you have nothing to add, select “No.”"
+ self.assertContains(response, expected_message)
+
+ def test_additional_details_form_fields_required(self):
+ """When a user submits the Additional Details form without checking the
+ has_cisa_representative and has_anything_else_text fields, the form should deny this action"""
+ domain_request = completed_domain_request(name="cisareps.gov", user=self.user, has_anything_else=False)
+
+ self.assertEqual(domain_request.has_anything_else_text, None)
+ self.assertEqual(domain_request.has_cisa_representative, None)
+
+ # prime the form by visiting /edit
+ self.app.get(reverse("edit-domain-request", kwargs={"id": domain_request.pk}))
+ # django-webtest does not handle cookie-based sessions well because it keeps
+ # resetting the session key on each new request, thus destroying the concept
+ # of a "session". We are going to do it manually, saving the session ID here
+ # and then setting the cookie on each request.
+ session_id = self.app.cookies[settings.SESSION_COOKIE_NAME]
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+
+ additional_details_page = self.app.get(reverse("domain-request:additional_details"))
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+
+ additional_details_form = additional_details_page.forms[0]
+
+ # Submit the form
+ response = additional_details_form.submit()
+
+ self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
+
+ # We expect to see this twice for both fields. This results in a count of 4
+ # due to screen reader information / html.
+ self.assertContains(response, "This question is required.", count=4)
+
def test_submitting_other_contacts_deletes_no_other_contacts_rationale(self):
"""When a user submits the Other Contacts form with other contacts selected, the domain request's
no other contacts rationale gets deleted"""
@@ -2328,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)
diff --git a/src/registrar/views/domain_request.py b/src/registrar/views/domain_request.py
index 244b47602..f93976138 100644
--- a/src/registrar/views/domain_request.py
+++ b/src/registrar/views/domain_request.py
@@ -45,7 +45,7 @@ class Step(StrEnum):
PURPOSE = "purpose"
YOUR_CONTACT = "your_contact"
OTHER_CONTACTS = "other_contacts"
- ANYTHING_ELSE = "anything_else"
+ ADDITIONAL_DETAILS = "additional_details"
REQUIREMENTS = "requirements"
REVIEW = "review"
@@ -91,7 +91,7 @@ class DomainRequestWizard(DomainRequestWizardPermissionView, TemplateView):
Step.PURPOSE: _("Purpose of your domain"),
Step.YOUR_CONTACT: _("Your contact information"),
Step.OTHER_CONTACTS: _("Other employees from your organization"),
- Step.ANYTHING_ELSE: _("Anything else?"),
+ Step.ADDITIONAL_DETAILS: _("Additional details"),
Step.REQUIREMENTS: _("Requirements for operating a .gov domain"),
Step.REVIEW: _("Review and submit your domain request"),
}
@@ -365,8 +365,9 @@ class DomainRequestWizard(DomainRequestWizardPermissionView, TemplateView):
self.domain_request.other_contacts.exists()
or self.domain_request.no_other_contacts_rationale is not None
),
- "anything_else": (
- self.domain_request.anything_else is not None or self.domain_request.is_policy_acknowledged is not None
+ "additional_details": (
+ (self.domain_request.anything_else is not None and self.domain_request.cisa_representative_email)
+ or self.domain_request.is_policy_acknowledged is not None
),
"requirements": self.domain_request.is_policy_acknowledged is not None,
"review": self.domain_request.is_policy_acknowledged is not None,
@@ -581,9 +582,64 @@ class OtherContacts(DomainRequestWizard):
return all_forms_valid
-class AnythingElse(DomainRequestWizard):
- template_name = "domain_request_anything_else.html"
- forms = [forms.AnythingElseForm]
+class AdditionalDetails(DomainRequestWizard):
+
+ template_name = "domain_request_additional_details.html"
+
+ forms = [
+ forms.CisaRepresentativeYesNoForm,
+ forms.CisaRepresentativeForm,
+ forms.AdditionalDetailsYesNoForm,
+ forms.AdditionalDetailsForm,
+ ]
+
+ def is_valid(self, forms: list) -> bool:
+
+ # Validate Cisa Representative
+ """Overrides default behavior defined in DomainRequestWizard.
+ Depending on value in yes_no forms, marks corresponding data
+ for deletion. Then validates all forms.
+ """
+ cisa_representative_email_yes_no_form = forms[0]
+ cisa_representative_email_form = forms[1]
+ anything_else_yes_no_form = forms[2]
+ anything_else_form = forms[3]
+
+ # ------- Validate cisa representative -------
+ cisa_rep_portion_is_valid = True
+ # test first for yes_no_form validity
+ if cisa_representative_email_yes_no_form.is_valid():
+ # test for existing data
+ if not cisa_representative_email_yes_no_form.cleaned_data.get("has_cisa_representative"):
+ # mark the cisa_representative_email_form for deletion
+ cisa_representative_email_form.mark_form_for_deletion()
+ else:
+ cisa_rep_portion_is_valid = cisa_representative_email_form.is_valid()
+ else:
+ # if yes no form is invalid, no choice has been made
+ # mark the cisa_representative_email_form for deletion
+ cisa_representative_email_form.mark_form_for_deletion()
+ cisa_rep_portion_is_valid = False
+
+ # ------- Validate anything else -------
+ anything_else_portion_is_valid = True
+ # test first for yes_no_form validity
+ if anything_else_yes_no_form.is_valid():
+ # test for existing data
+ if not anything_else_yes_no_form.cleaned_data.get("has_anything_else_text"):
+ # mark the anything_else_form for deletion
+ anything_else_form.mark_form_for_deletion()
+ else:
+ anything_else_portion_is_valid = anything_else_form.is_valid()
+ else:
+ # if yes no form is invalid, no choice has been made
+ # mark the anything_else_form for deletion
+ anything_else_form.mark_form_for_deletion()
+ anything_else_portion_is_valid = False
+
+ # ------- Return combined validation result -------
+ all_forms_valid = cisa_rep_portion_is_valid and anything_else_portion_is_valid
+ return all_forms_valid
class Requirements(DomainRequestWizard):
diff --git a/src/requirements.txt b/src/requirements.txt
index 067a174e9..d4878748a 100644
--- a/src/requirements.txt
+++ b/src/requirements.txt
@@ -1,8 +1,8 @@
-i https://pypi.python.org/simple
annotated-types==0.6.0; python_version >= '3.8'
asgiref==3.8.1; python_version >= '3.8'
-boto3==1.34.88; python_version >= '3.8'
-botocore==1.34.88; python_version >= '3.8'
+boto3==1.34.90; python_version >= '3.8'
+botocore==1.34.90; python_version >= '3.8'
cachetools==5.3.3; python_version >= '3.7'
certifi==2024.2.2; python_version >= '3.6'
cfenv==0.5.3
@@ -16,7 +16,7 @@ dj-email-url==1.0.6
django==4.2.10; python_version >= '3.8'
django-admin-multiple-choice-list-filter==0.1.1
django-allow-cidr==0.7.1
-django-auditlog==2.3.0; python_version >= '3.7'
+django-auditlog==3.0.0; python_version >= '3.8'
django-cache-url==3.4.5
django-cors-headers==4.3.1; python_version >= '3.8'
django-csp==3.8
@@ -50,8 +50,8 @@ phonenumberslite==8.13.35
psycopg2-binary==2.9.9; python_version >= '3.7'
pycparser==2.22; python_version >= '3.8'
pycryptodomex==3.20.0; python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3, 3.4'
-pydantic==2.7.0; python_version >= '3.8'
-pydantic-core==2.18.1; python_version >= '3.8'
+pydantic==2.7.1; python_version >= '3.8'
+pydantic-core==2.18.2; python_version >= '3.8'
pydantic-settings==2.2.1; python_version >= '3.8'
pyjwkest==1.4.2
python-dateutil==2.9.0.post0; python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'