Merge branch 'main' into za/1450-no-name-for-invitation-email

docs/operations/data_migration.md

@@ -493,3 +493,34 @@ The `load_organization_data` script has five optional parameters. These are as f
 | 3 | **directory**                    | Specifies the directory containing the files that will be parsed. Defaults to "migrationdata" |
 | 4 | **domain_additional_filename**   | Specifies the filename of domain_additional. Used as an override for the JSON. Has no default. |
 | 5 | **organization_adhoc_filename**  | Specifies the filename of organization_adhoc. Used as an override for the JSON. Has no default. |
+
+
+## Extend Domain Extension Dates
+This section outlines how to extend the expiration date of all ready domains (or a select subset) by a defined period of time. 
+
+### Running on sandboxes
+
+#### Step 1: Login to CloudFoundry
+```cf login -a api.fr.cloud.gov --sso```
+
+#### Step 2: SSH into your environment
+```cf ssh getgov-{space}```
+
+Example: `cf ssh getgov-za`
+
+#### Step 3: Create a shell instance
+```/tmp/lifecycle/shell```
+
+#### Step 4: Extend domains
+```./manage.py extend_expiration_dates```
+
+### Running locally
+```docker-compose exec app ./manage.py extend_expiration_dates```
+
+##### Optional parameters
+|   | Parameter                  | Description                                                                 |
+|:-:|:-------------------------- |:----------------------------------------------------------------------------|
+| 1 | **extensionAmount**        | Determines the period of time to extend by, in years. Defaults to 1 year.   |
+| 2 | **debug**                  | Increases logging detail. Defaults to False.                                |
+| 3 | **limitParse**             | Determines how many domains to parse. Defaults to all.                      |
+| 4 | **disableIdempotentCheck** | Boolean that determines if we should check for idempotence or not. Compares the proposed extension date to the value in TransitionDomains. Defaults to False. |

src/.pa11yci

@@ -19,7 +19,6 @@
         "http://localhost:8080/register/other_contacts/",
         "http://localhost:8080/register/anything_else/",
         "http://localhost:8080/register/requirements/",
-        "http://localhost:8080/register/review/",
         "http://localhost:8080/register/finished/"
     ]
 }

src/api/views.py

@@ -91,15 +91,17 @@ def available(request, domain=""):
     # validate that the given domain could be a domain name and fail early if
     # not.
     if not (DraftDomain.string_could_be_domain(domain) or DraftDomain.string_could_be_domain(domain + ".gov")):
-        return JsonResponse({"available": False, "message": DOMAIN_API_MESSAGES["invalid"]})
+        return JsonResponse({"available": False, "code": "invalid", "message": DOMAIN_API_MESSAGES["invalid"]})
     # a domain is available if it is NOT in the list of current domains
     try:
         if check_domain_available(domain):
-            return JsonResponse({"available": True, "message": DOMAIN_API_MESSAGES["success"]})
+            return JsonResponse({"available": True, "code": "success", "message": DOMAIN_API_MESSAGES["success"]})
         else:
-            return JsonResponse({"available": False, "message": DOMAIN_API_MESSAGES["unavailable"]})
+            return JsonResponse(
+                {"available": False, "code": "unavailable", "message": DOMAIN_API_MESSAGES["unavailable"]}
+            )
     except Exception:
-        return JsonResponse({"available": False, "message": DOMAIN_API_MESSAGES["error"]})
+        return JsonResponse({"available": False, "code": "error", "message": DOMAIN_API_MESSAGES["error"]})
 
 
 @require_http_methods(["GET"])

src/djangooidc/backends.py

@@ -46,8 +46,14 @@ class OpenIdConnectBackend(ModelBackend):
                 # defaults _will_ be updated, these are not fallbacks
                 "defaults": openid_data,
             }
-            user, created = UserModel.objects.update_or_create(**args)
-            if created:
+
+            user, created = UserModel.objects.get_or_create(**args)
+
+            if not created:
+                # If user exists, update existing user
+                self.update_existing_user(user, args["defaults"])
+            else:
+                # If user is created, configure the user
                 user = self.configure_user(user, **kwargs)
         else:
             try:
@@ -58,6 +64,16 @@ class OpenIdConnectBackend(ModelBackend):
         user.on_each_login()
         return user
 
+    def update_existing_user(self, user, kwargs):
+        """Update other fields without overwriting first_name and last_name.
+        Overwrite first_name and last_name if not empty string"""
+
+        for key, value in kwargs.items():
+            # Check if the key is not first_name or last_name or value is not empty string
+            if key not in ["first_name", "last_name"] or value:
+                setattr(user, key, value)
+        user.save()
+
     def clean_username(self, username):
         """
         Performs any cleaning on the "username" prior to using it to get or

src/djangooidc/tests/test_backends.py

@@ -0,0 +1,99 @@
+from django.test import TestCase
+from registrar.models import User
+from ..backends import OpenIdConnectBackend  # Adjust the import path based on your project structure
+
+
+class OpenIdConnectBackendTestCase(TestCase):
+    def setUp(self):
+        self.backend = OpenIdConnectBackend()
+        self.kwargs = {
+            "sub": "test_user",
+            "given_name": "John",
+            "family_name": "Doe",
+            "email": "john.doe@example.com",
+            "phone": "123456789",
+        }
+
+    def tearDown(self) -> None:
+        User.objects.all().delete()
+
+    def test_authenticate_with_create_user(self):
+        """Test that authenticate creates a new user if it does not find
+        existing user"""
+        # Ensure that the authenticate method creates a new user
+        user = self.backend.authenticate(request=None, **self.kwargs)
+        self.assertIsNotNone(user)
+        self.assertIsInstance(user, User)
+        self.assertEqual(user.username, "test_user")
+
+        # Verify that user fields are correctly set
+        self.assertEqual(user.first_name, "John")
+        self.assertEqual(user.last_name, "Doe")
+        self.assertEqual(user.email, "john.doe@example.com")
+        self.assertEqual(user.phone, "123456789")
+
+    def test_authenticate_with_existing_user(self):
+        """Test that authenticate updates an existing user if it finds one.
+        For this test, given_name and family_name are supplied"""
+        # Create an existing user with the same username
+        existing_user = User.objects.create_user(username="test_user")
+
+        # Ensure that the authenticate method updates the existing user
+        user = self.backend.authenticate(request=None, **self.kwargs)
+        self.assertIsNotNone(user)
+        self.assertIsInstance(user, User)
+        self.assertEqual(user, existing_user)  # The same user instance should be returned
+
+        # Verify that user fields are correctly updated
+        self.assertEqual(user.first_name, "John")
+        self.assertEqual(user.last_name, "Doe")
+        self.assertEqual(user.email, "john.doe@example.com")
+        self.assertEqual(user.phone, "123456789")
+
+    def test_authenticate_with_existing_user_no_name(self):
+        """Test that authenticate updates an existing user if it finds one.
+        For this test, given_name and family_name are not supplied"""
+        # Create an existing user with the same username and with first and last names
+        existing_user = User.objects.create_user(username="test_user", first_name="John", last_name="Doe")
+
+        # Remove given_name and family_name from the input, self.kwargs
+        self.kwargs.pop("given_name", None)
+        self.kwargs.pop("family_name", None)
+
+        # Ensure that the authenticate method updates the existing user
+        # and preserves existing first and last names
+        user = self.backend.authenticate(request=None, **self.kwargs)
+        self.assertIsNotNone(user)
+        self.assertIsInstance(user, User)
+        self.assertEqual(user, existing_user)  # The same user instance should be returned
+
+        # Verify that user fields are correctly updated
+        self.assertEqual(user.first_name, "John")
+        self.assertEqual(user.last_name, "Doe")
+        self.assertEqual(user.email, "john.doe@example.com")
+        self.assertEqual(user.phone, "123456789")
+
+    def test_authenticate_with_existing_user_different_name(self):
+        """Test that authenticate updates an existing user if it finds one.
+        For this test, given_name and family_name are supplied and overwrite"""
+        # Create an existing user with the same username and with first and last names
+        existing_user = User.objects.create_user(username="test_user", first_name="WillBe", last_name="Replaced")
+
+        # Ensure that the authenticate method updates the existing user
+        # and preserves existing first and last names
+        user = self.backend.authenticate(request=None, **self.kwargs)
+        self.assertIsNotNone(user)
+        self.assertIsInstance(user, User)
+        self.assertEqual(user, existing_user)  # The same user instance should be returned
+
+        # Verify that user fields are correctly updated
+        self.assertEqual(user.first_name, "John")
+        self.assertEqual(user.last_name, "Doe")
+        self.assertEqual(user.email, "john.doe@example.com")
+        self.assertEqual(user.phone, "123456789")
+
+    def test_authenticate_with_unknown_user(self):
+        """Test that authenticate returns None when no kwargs are supplied"""
+        # Ensure that the authenticate method handles the case when the user is not found
+        user = self.backend.authenticate(request=None, **{})
+        self.assertIsNone(user)

src/registrar/management/commands/copy_names_from_contacts_to_users.py

@@ -0,0 +1,235 @@
+import logging
+import argparse
+import sys
+
+from django.core.management import BaseCommand
+
+from registrar.management.commands.utility.terminal_helper import (
+    TerminalColors,
+    TerminalHelper,
+)
+from registrar.models.contact import Contact
+from registrar.models.user import User
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    help = """Copy first and last names from a contact to
+    a related user if it exists and if its first and last name
+    properties are null or blank strings."""
+
+    # ======================================================
+    # ===================== ARGUMENTS  =====================
+    # ======================================================
+    def add_arguments(self, parser):
+        parser.add_argument("--debug", action=argparse.BooleanOptionalAction)
+
+    # ======================================================
+    # ===================== PRINTING  ======================
+    # ======================================================
+    def print_debug_mode_statements(self, debug_on: bool):
+        """Prints additional terminal statements to indicate if --debug
+        or --limitParse are in use"""
+        TerminalHelper.print_conditional(
+            debug_on,
+            f"""{TerminalColors.OKCYAN}
+            ----------DEBUG MODE ON----------
+            Detailed print statements activated.
+            {TerminalColors.ENDC}
+            """,
+        )
+
+    def print_summary_of_findings(
+        self,
+        skipped_contacts,
+        eligible_users,
+        processed_users,
+        debug_on,
+    ):
+        """Prints to terminal a summary of findings from
+        copying first and last names from contacts to users"""
+
+        total_eligible_users = len(eligible_users)
+        total_skipped_contacts = len(skipped_contacts)
+        total_processed_users = len(processed_users)
+
+        logger.info(
+            f"""{TerminalColors.OKGREEN}
+            ============= FINISHED ===============
+            Skipped {total_skipped_contacts} contacts
+            Found {total_eligible_users} users linked to contacts
+            Processed {total_processed_users} users
+            {TerminalColors.ENDC}
+            """  # noqa
+        )
+
+        # DEBUG:
+        TerminalHelper.print_conditional(
+            debug_on,
+            f"""{TerminalColors.YELLOW}
+            ======= DEBUG OUTPUT =======
+            Users who have a linked contact:
+            {eligible_users}
+
+            Processed users (users who have a linked contact and a missing first or last name):
+            {processed_users}
+
+            ===== SKIPPED CONTACTS =====
+            {skipped_contacts}
+
+            {TerminalColors.ENDC}
+            """,
+        )
+
+    # ======================================================
+    # ===================    USER    =====================
+    # ======================================================
+    def update_user(self, contact: Contact, debug_on: bool):
+        """Given a contact with a first_name and last_name, find & update an existing
+        corresponding user if her first_name and last_name are null.
+
+        Returns tuple of eligible (is linked to the contact) and processed
+        (first and last are blank) users.
+        """
+
+        user_exists = User.objects.filter(contact=contact).exists()
+        if user_exists:
+            try:
+                # ----------------------- UPDATE USER -----------------------
+                # ---- GET THE USER
+                eligible_user = User.objects.get(contact=contact)
+                processed_user = None
+                # DEBUG:
+                TerminalHelper.print_conditional(
+                    debug_on,
+                    f"""{TerminalColors.YELLOW}
+                    > Found linked user for contact:
+                    {contact} {contact.email} {contact.first_name} {contact.last_name}
+                    > The linked user is {eligible_user} {eligible_user.username}
+                    {TerminalColors.ENDC}""",  # noqa
+                )
+
+                # ---- UPDATE THE USER IF IT DOES NOT HAVE A FIRST AND LAST NAMES
+                # ---- LET'S KEEP A LIGHT TOUCH
+                if not eligible_user.first_name and not eligible_user.last_name:
+                    # (expression has type "str | None", variable has type "str | int | Combinable")
+                    # so we'll ignore type
+                    eligible_user.first_name = contact.first_name  # type: ignore
+                    eligible_user.last_name = contact.last_name  # type: ignore
+                    eligible_user.save()
+                    processed_user = eligible_user
+
+                return (
+                    eligible_user,
+                    processed_user,
+                )
+
+            except Exception as error:
+                logger.warning(
+                    f"""
+                    {TerminalColors.FAIL}
+                    !!! ERROR: An exception occured in the
+                    User table for the following user:
+                    {contact.email} {contact.first_name} {contact.last_name}
+
+                    Exception is: {error}
+                    ----------TERMINATING----------"""
+                )
+                sys.exit()
+        else:
+            return None, None
+
+    # ======================================================
+    # ================= PROCESS CONTACTS  ==================
+    # ======================================================
+
+    def process_contacts(
+        self,
+        debug_on,
+        skipped_contacts=[],
+        eligible_users=[],
+        processed_users=[],
+    ):
+        for contact in Contact.objects.all():
+            TerminalHelper.print_conditional(
+                debug_on,
+                f"{TerminalColors.OKCYAN}"
+                "Processing Contact: "
+                f"{contact.email},"
+                f" {contact.first_name},"
+                f" {contact.last_name}"
+                f"{TerminalColors.ENDC}",
+            )
+
+            # ======================================================
+            # ====================== USER  =======================
+            (eligible_user, processed_user) = self.update_user(contact, debug_on)
+
+            debug_string = ""
+            if eligible_user:
+                # ---------------- UPDATED ----------------
+                eligible_users.append(contact.email)
+                debug_string = f"eligible user: {eligible_user}"
+                if processed_user:
+                    processed_users.append(contact.email)
+                    debug_string = f"processed user: {processed_user}"
+            else:
+                skipped_contacts.append(contact.email)
+                debug_string = f"skipped user: {contact.email}"
+
+            # DEBUG:
+            TerminalHelper.print_conditional(
+                debug_on,
+                (f"{TerminalColors.OKCYAN} {debug_string} {TerminalColors.ENDC}"),
+            )
+
+        return (
+            skipped_contacts,
+            eligible_users,
+            processed_users,
+        )
+
+    # ======================================================
+    # ===================== HANDLE  ========================
+    # ======================================================
+    def handle(
+        self,
+        **options,
+    ):
+        """Parse entries in Contact table
+        and update valid corresponding entries in the
+        User table."""
+
+        # grab command line arguments and store locally...
+        debug_on = options.get("debug")
+
+        self.print_debug_mode_statements(debug_on)
+
+        logger.info(
+            f"""{TerminalColors.OKCYAN}
+            ==========================
+            Beginning Data Transfer
+            ==========================
+            {TerminalColors.ENDC}"""
+        )
+
+        logger.info(
+            f"""{TerminalColors.OKCYAN}
+            ========= Adding Domains and Domain Invitations =========
+            {TerminalColors.ENDC}"""
+        )
+        (
+            skipped_contacts,
+            eligible_users,
+            processed_users,
+        ) = self.process_contacts(
+            debug_on,
+        )
+
+        self.print_summary_of_findings(
+            skipped_contacts,
+            eligible_users,
+            processed_users,
+            debug_on,
+        )

src/registrar/management/commands/extend_expiration_dates.py

@@ -0,0 +1,212 @@
+"""Data migration: Extends expiration dates for valid domains"""
+
+import argparse
+from datetime import date
+import logging
+
+from django.core.management import BaseCommand
+from epplibwrapper.errors import RegistryError
+from registrar.models import Domain
+from registrar.management.commands.utility.terminal_helper import TerminalColors, TerminalHelper
+
+from registrar.models.transition_domain import TransitionDomain
+
+try:
+    from epplib.exceptions import TransportError
+except ImportError:
+    pass
+
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    help = "Extends expiration dates for valid domains"
+
+    def __init__(self):
+        """Sets global variables for code tidyness"""
+        super().__init__()
+        self.update_success = []
+        self.update_skipped = []
+        self.update_failed = []
+        self.expiration_minimum_cutoff = date(2023, 11, 15)
+        self.expiration_maximum_cutoff = date(2023, 12, 30)
+
+    def add_arguments(self, parser):
+        """Add command line arguments."""
+        parser.add_argument(
+            "--extensionAmount",
+            type=int,
+            default=1,
+            help="Determines the period (in years) to extend expiration dates by",
+        )
+        parser.add_argument(
+            "--limitParse",
+            type=int,
+            default=0,
+            help="Sets a cap on the number of records to parse",
+        )
+        parser.add_argument(
+            "--disableIdempotentCheck", action=argparse.BooleanOptionalAction, help="Disable script idempotence"
+        )
+        parser.add_argument("--debug", action=argparse.BooleanOptionalAction, help="Increases log chattiness")
+
+    def handle(self, **options):
+        """
+        Extends the expiration dates for valid domains.
+
+        If a parse limit is set and it's less than the total number of valid domains,
+        the number of domains to change is set to the parse limit.
+
+        Includes an idempotence check.
+        """
+
+        # Retrieve command line options
+        extension_amount = options.get("extensionAmount")
+        limit_parse = options.get("limitParse")
+        disable_idempotence = options.get("disableIdempotentCheck")
+        debug = options.get("debug")
+
+        # Does a check to see if parse_limit is a positive int.
+        # Raise an error if not.
+        self.check_if_positive_int(limit_parse, "limitParse")
+
+        valid_domains = Domain.objects.filter(
+            expiration_date__gte=self.expiration_minimum_cutoff,
+            expiration_date__lte=self.expiration_maximum_cutoff,
+            state=Domain.State.READY,
+        ).order_by("name")
+
+        domains_to_change_count = valid_domains.count()
+        if limit_parse != 0:
+            domains_to_change_count = limit_parse
+            valid_domains = valid_domains[:limit_parse]
+
+        # Determines if we should continue code execution or not.
+        # If the user prompts 'N', a sys.exit() will be called.
+        self.prompt_user_to_proceed(extension_amount, domains_to_change_count)
+
+        for domain in valid_domains:
+            try:
+                is_idempotent = self.idempotence_check(domain, extension_amount)
+                if not disable_idempotence and not is_idempotent:
+                    self.update_skipped.append(domain.name)
+                    logger.info(f"{TerminalColors.YELLOW}" f"Skipping update for {domain}" f"{TerminalColors.ENDC}")
+                else:
+                    domain.renew_domain(extension_amount)
+                    self.update_success.append(domain.name)
+                    logger.info(
+                        f"{TerminalColors.OKCYAN}"
+                        f"Successfully updated expiration date for {domain}"
+                        f"{TerminalColors.ENDC}"
+                    )
+            # Catches registry errors. Failures indicate bad data, or a faulty connection.
+            except (RegistryError, KeyError, TransportError) as err:
+                self.update_failed.append(domain.name)
+                logger.error(
+                    f"{TerminalColors.FAIL}" f"Failed to update expiration date for {domain}" f"{TerminalColors.ENDC}"
+                )
+                logger.error(err)
+            except Exception as err:
+                self.log_script_run_summary(debug)
+                raise err
+        self.log_script_run_summary(debug)
+
+    # == Helper functions == #
+    def idempotence_check(self, domain: Domain, extension_amount):
+        """Determines if the proposed operation violates idempotency"""
+        # Because our migration data had a hard stop date, we can determine if our change
+        # is valid simply checking the date is within a valid range and it was updated
+        # in epp or not.
+        # CAVEAT: This is a workaround. A more robust solution would be a db flag
+        current_expiration_date = domain.registry_expiration_date
+        transition_domains = TransitionDomain.objects.filter(
+            domain_name=domain.name, epp_expiration_date=current_expiration_date
+        )
+
+        return transition_domains.count() > 0
+
+    def prompt_user_to_proceed(self, extension_amount, domains_to_change_count):
+        """Asks if the user wants to proceed with this action"""
+        TerminalHelper.prompt_for_execution(
+            system_exit_on_terminate=True,
+            info_to_inspect=f"""
+            ==Extension Amount==
+            Period: {extension_amount} year(s)
+
+            ==Proposed Changes==
+            Domains to change: {domains_to_change_count}
+            """,
+            prompt_title="Do you wish to proceed with these changes?",
+        )
+
+        logger.info(f"{TerminalColors.MAGENTA}" "Preparing to extend expiration dates..." f"{TerminalColors.ENDC}")
+
+    def check_if_positive_int(self, value: int, var_name: str):
+        """
+        Determines if the given integer value is positive or not.
+        If not, it raises an ArgumentTypeError
+        """
+        if value < 0:
+            raise argparse.ArgumentTypeError(
+                f"{value} is an invalid integer value for {var_name}. " "Must be positive."
+            )
+
+        return value
+
+    def log_script_run_summary(self, debug):
+        """Prints success, failed, and skipped counts, as well as
+        all affected domains."""
+        update_success_count = len(self.update_success)
+        update_failed_count = len(self.update_failed)
+        update_skipped_count = len(self.update_skipped)
+
+        # Prepare debug messages
+        debug_messages = {
+            "success": (f"{TerminalColors.OKCYAN}Updated these Domains: {self.update_success}{TerminalColors.ENDC}\n"),
+            "skipped": (f"{TerminalColors.YELLOW}Skipped these Domains: {self.update_skipped}{TerminalColors.ENDC}\n"),
+            "failed": (
+                f"{TerminalColors.FAIL}Failed to update these Domains: {self.update_failed}{TerminalColors.ENDC}\n"
+            ),
+        }
+
+        # Print out a list of everything that was changed, if we have any changes to log.
+        # Otherwise, don't print anything.
+        TerminalHelper.print_conditional(
+            debug,
+            f"{debug_messages.get('success') if update_success_count > 0 else ''}"
+            f"{debug_messages.get('skipped') if update_skipped_count > 0 else ''}"
+            f"{debug_messages.get('failed') if update_failed_count > 0 else ''}",
+        )
+
+        if update_failed_count == 0 and update_skipped_count == 0:
+            logger.info(
+                f"""{TerminalColors.OKGREEN}
+                ============= FINISHED ===============
+                Updated {update_success_count} Domain entries
+                {TerminalColors.ENDC}
+                """
+            )
+        elif update_failed_count == 0:
+            logger.info(
+                f"""{TerminalColors.YELLOW}
+                ============= FINISHED ===============
+                Updated {update_success_count} Domain entries
+
+                ----- IDEMPOTENCY CHECK FAILED -----
+                Skipped updating {update_skipped_count} Domain entries
+                {TerminalColors.ENDC}
+                """
+            )
+        else:
+            logger.info(
+                f"""{TerminalColors.FAIL}
+                ============= FINISHED ===============
+                Updated {update_success_count} Domain entries
+
+                ----- UPDATE FAILED -----
+                Failed to update {update_failed_count} Domain entries,
+                Skipped updating {update_skipped_count} Domain entries
+                {TerminalColors.ENDC}
+                """
+            )

src/registrar/models/contact.py

@@ -59,6 +59,16 @@ class Contact(TimeStampedModel):
         names = [n for n in [self.first_name, self.middle_name, self.last_name] if n]
         return " ".join(names) if names else "Unknown"
 
+    def save(self, *args, **kwargs):
+        # Call the parent class's save method to perform the actual save
+        super().save(*args, **kwargs)
+
+        # Update the related User object's first_name and last_name
+        if self.user:
+            self.user.first_name = self.first_name
+            self.user.last_name = self.last_name
+            self.user.save()
+
     def __str__(self):
         if self.first_name or self.last_name:
             return self.get_formatted_name()

src/registrar/models/domain.py

@@ -1195,7 +1195,7 @@ class Domain(TimeStampedModel, DomainHelper):
                     logger.error(e)
                     logger.error(e.code)
                     raise e
-                if e.code == ErrorCode.OBJECT_DOES_NOT_EXIST and self.state != Domain.State.DELETED:
+                if e.code == ErrorCode.OBJECT_DOES_NOT_EXIST and self.state == Domain.State.UNKNOWN:
                     # avoid infinite loop
                     already_tried_to_create = True
                     self.dns_needed_from_unknown()

src/registrar/models/domain_application.py

@@ -122,7 +122,7 @@ class DomainApplication(TimeStampedModel):
 
         FEDERAL = (
             "federal",
-            "Federal: an agency of the U.S. government's executive, legislative, or judicial branches",
+            "Federal: an agency of the U.S. government’s legislative, executive, or judicial branches",
         )
         INTERSTATE = "interstate", "Interstate: an organization of two or more states"
         STATE_OR_TERRITORY = (
@@ -139,7 +139,7 @@ class DomainApplication(TimeStampedModel):
         CITY = "city", "City: a city, town, township, village, etc."
         SPECIAL_DISTRICT = (
             "special_district",
-            "Special district: an independent organization within a single state",
+            "Special district: an independent government that delivers specialized, essential services",
         )
         SCHOOL_DISTRICT = (
             "school_district",

src/registrar/templates/application_form.html

@@ -85,16 +85,29 @@
               class="usa-button usa-button--outline"
             >Save and return to manage your domains</button>
             {% else %}
-            <button
-              type="submit"
+            <a
+              href="#toggle-submit-domain-request"
               class="usa-button usa-button--big dotgov-button--green"
-            >Submit your domain request</button>
+              aria-controls="toggle-submit-domain-request"
+              data-open-modal
+              >Submit your domain request</a
+            >
             {% endif %}
           </div>
 {% endblock %}
 
         </form>
 
+        <div
+          class="usa-modal"
+          id="toggle-submit-domain-request"
+          aria-labelledby="Are you sure you want to submit a domain request?"
+          aria-describedby="Are you sure you want to submit a domain request?"
+          data-force-action
+        >
+            {% include 'includes/modal.html' with modal_heading=modal_heading|safe modal_description="Once you submit this request, you won’t be able to make further edits until it’s reviewed by our staff. You’ll only be able to withdraw your request." modal_button=modal_button|safe %}
+        </div>
+
 {% block after_form_content %}{% endblock %}
 
       </main>

src/registrar/templates/domain_dns.html

@@ -12,7 +12,7 @@
   <p>You can enter your name servers, as well as other DNS-related information, in the following sections:</p>
 
   {% url 'domain-dns-nameservers' pk=domain.id as url %}
-<ul>  
+<ul class="usa-list">
 <li><a href="{{ url }}">Name servers</a></li>
 
   {% url 'domain-dns-dnssec' pk=domain.id as url %}

src/registrar/tests/common.py

@@ -5,6 +5,7 @@ import logging
 from contextlib import contextmanager
 import random
 from string import ascii_uppercase
+import uuid
 from django.test import TestCase
 from unittest.mock import MagicMock, Mock, patch
 from typing import List, Dict
@@ -161,7 +162,7 @@ class AuditedAdminMockData:
         user = User.objects.get_or_create(
             first_name="{} first_name:{}".format(item_name, short_hand),
             last_name="{} last_name:{}".format(item_name, short_hand),
-            username="{} username:{}".format(item_name, short_hand),
+            username="{} username:{}".format(item_name + str(uuid.uuid4())[:8], short_hand),
         )[0]
         return user
 
@@ -405,8 +406,8 @@ def mock_user():
     """A simple user."""
     user_kwargs = dict(
         id=4,
-        first_name="Rachid",
-        last_name="Mrad",
+        first_name="Jeff",
+        last_name="Lebowski",
     )
     mock_user, _ = User.objects.get_or_create(**user_kwargs)
     return mock_user
@@ -619,6 +620,17 @@ class MockEppLib(TestCase):
         ],
         ex_date=datetime.date(2023, 5, 25),
     )
+    mockDataExtensionDomain = fakedEppObject(
+        "fakePw",
+        cr_date=datetime.datetime(2023, 5, 25, 19, 45, 35),
+        contacts=[common.DomainContact(contact="123", type=PublicContact.ContactTypeChoices.SECURITY)],
+        hosts=["fake.host.com"],
+        statuses=[
+            common.Status(state="serverTransferProhibited", description="", lang="en"),
+            common.Status(state="inactive", description="", lang="en"),
+        ],
+        ex_date=datetime.date(2023, 11, 15),
+    )
     mockDataInfoContact = mockDataInfoDomain.dummyInfoContactResultData(
         "123", "123@mail.gov", datetime.datetime(2023, 5, 25, 19, 45, 35), "lastPw"
     )
@@ -819,6 +831,21 @@ class MockEppLib(TestCase):
         ex_date=datetime.date(2023, 5, 25),
     )
 
+    mockDnsNeededRenewedDomainExpDate = fakedEppObject(
+        "fakeneeded.gov",
+        ex_date=datetime.date(2023, 2, 15),
+    )
+
+    mockMaximumRenewedDomainExpDate = fakedEppObject(
+        "fakemaximum.gov",
+        ex_date=datetime.date(2024, 12, 31),
+    )
+
+    mockRecentRenewedDomainExpDate = fakedEppObject(
+        "waterbutpurple.gov",
+        ex_date=datetime.date(2024, 11, 15),
+    )
+
     def _mockDomainName(self, _name, _avail=False):
         return MagicMock(
             res_data=[
@@ -917,6 +944,21 @@ class MockEppLib(TestCase):
     def mockRenewDomainCommand(self, _request, cleaned):
         if getattr(_request, "name", None) == "fake-error.gov":
             raise RegistryError(code=ErrorCode.PARAMETER_VALUE_RANGE_ERROR)
+        elif getattr(_request, "name", None) == "waterbutpurple.gov":
+            return MagicMock(
+                res_data=[self.mockRecentRenewedDomainExpDate],
+                code=ErrorCode.COMMAND_COMPLETED_SUCCESSFULLY,
+            )
+        elif getattr(_request, "name", None) == "fakeneeded.gov":
+            return MagicMock(
+                res_data=[self.mockDnsNeededRenewedDomainExpDate],
+                code=ErrorCode.COMMAND_COMPLETED_SUCCESSFULLY,
+            )
+        elif getattr(_request, "name", None) == "fakemaximum.gov":
+            return MagicMock(
+                res_data=[self.mockMaximumRenewedDomainExpDate],
+                code=ErrorCode.COMMAND_COMPLETED_SUCCESSFULLY,
+            )
         else:
             return MagicMock(
                 res_data=[self.mockRenewedDomainExpDate],
@@ -942,6 +984,7 @@ class MockEppLib(TestCase):
                 self.infoDomainTwoHosts if self.mockedSendFunction.call_count == 5 else self.infoDomainNoHost,
                 None,
             ),
+            "waterbutpurple.gov": (self.mockDataExtensionDomain, None),
             "nameserverwithip.gov": (self.infoDomainHasIP, None),
             "namerserversubdomain.gov": (self.infoDomainCheckHostIPCombo, None),
             "freeman.gov": (self.InfoDomainWithContacts, None),

src/registrar/tests/test_admin.py

@@ -1023,7 +1023,7 @@ class ListHeaderAdminTest(TestCase):
         # Set the GET parameters for testing
         request.GET = {
             "status": "started",
-            "investigator": "Rachid Mrad",
+            "investigator": "Jeff Lebowski",
             "q": "search_value",
         }
         # Call the get_filters method
@@ -1034,7 +1034,7 @@ class ListHeaderAdminTest(TestCase):
             filters,
             [
                 {"parameter_name": "status", "parameter_value": "started"},
-                {"parameter_name": "investigator", "parameter_value": "Rachid Mrad"},
+                {"parameter_name": "investigator", "parameter_value": "Jeff Lebowski"},
             ],
         )
 
@@ -1110,8 +1110,8 @@ class AuditedAdminTest(TestCase):
         tested_fields = [
             DomainApplication.authorizing_official.field,
             DomainApplication.submitter.field,
-            DomainApplication.investigator.field,
-            DomainApplication.creator.field,
+            # DomainApplication.investigator.field,
+            # DomainApplication.creator.field,
             DomainApplication.requested_domain.field,
         ]
 
@@ -1166,7 +1166,7 @@ class AuditedAdminTest(TestCase):
         tested_fields = [
             DomainInformation.authorizing_official.field,
             DomainInformation.submitter.field,
-            DomainInformation.creator.field,
+            # DomainInformation.creator.field,
             (DomainInformation.domain.field, ["name"]),
             (DomainInformation.domain_application.field, ["requested_domain__name"]),
         ]

src/registrar/tests/test_copy_names_from_contacts_to_users.py

@@ -0,0 +1,98 @@
+from django.test import TestCase
+
+from registrar.models import (
+    User,
+    Contact,
+)
+
+from registrar.management.commands.copy_names_from_contacts_to_users import Command
+
+
+class TestDataUpdates(TestCase):
+    def setUp(self):
+        """We cannot setup the user details because contacts will override the first and last names in its save method
+        so we will initiate the users, setup the contacts and link them, and leave the rest of the setup to the test(s).
+        """
+
+        self.user1 = User.objects.create(username="user1")
+        self.user2 = User.objects.create(username="user2")
+        self.user3 = User.objects.create(username="user3")
+        self.user4 = User.objects.create(username="user4")
+        # The last user created triggers the creation of a contact and attaches itself to it. See signals.
+        # This bs_user defuses that situation.
+        self.bs_user = User.objects.create()
+
+        self.contact1 = Contact.objects.create(
+            user=self.user1, email="email1@igorville.gov", first_name="first1", last_name="last1"
+        )
+        self.contact2 = Contact.objects.create(
+            user=self.user2, email="email2@igorville.gov", first_name="first2", last_name="last2"
+        )
+        self.contact3 = Contact.objects.create(
+            user=self.user3, email="email3@igorville.gov", first_name="first3", last_name="last3"
+        )
+        self.contact4 = Contact.objects.create(email="email4@igorville.gov", first_name="first4", last_name="last4")
+
+        self.command = Command()
+
+    def tearDown(self):
+        """Clean up"""
+        # Delete users and contacts
+        User.objects.all().delete()
+        Contact.objects.all().delete()
+
+    def test_script_updates_linked_users(self):
+        """Test the script that copies contacts' first and last names into associated users that
+        are eligible (first or last are blank or undefined)"""
+
+        # Set up the users' first and last names here so
+        # they that they don't get overwritten by Contact's save()
+        # User with no first or last names
+        self.user1.first_name = ""
+        self.user1.last_name = ""
+        self.user1.save()
+
+        # User with a first name but no last name
+        self.user2.first_name = "First name but no last name"
+        self.user2.last_name = ""
+        self.user2.save()
+
+        # User with a first and last name
+        self.user3.first_name = "An existing first name"
+        self.user3.last_name = "An existing last name"
+        self.user3.save()
+
+        # Call the parent method the same way we do it in the script
+        skipped_contacts = []
+        eligible_users = []
+        processed_users = []
+        (
+            skipped_contacts,
+            eligible_users,
+            processed_users,
+        ) = self.command.process_contacts(
+            # Set debugging to False
+            False,
+            skipped_contacts,
+            eligible_users,
+            processed_users,
+        )
+
+        # Trigger DB refresh
+        self.user1.refresh_from_db()
+        self.user2.refresh_from_db()
+        self.user3.refresh_from_db()
+
+        # Asserts
+        # The user that has no first and last names will get them from the contact
+        self.assertEqual(self.user1.first_name, "first1")
+        self.assertEqual(self.user1.last_name, "last1")
+        # The user that has a first but no last will be left alone
+        self.assertEqual(self.user2.first_name, "First name but no last name")
+        self.assertEqual(self.user2.last_name, "")
+        # The user that has a first and a last will be left alone
+        self.assertEqual(self.user3.first_name, "An existing first name")
+        self.assertEqual(self.user3.last_name, "An existing last name")
+        # The unlinked user will be left alone
+        self.assertEqual(self.user4.first_name, "")
+        self.assertEqual(self.user4.last_name, "")

src/registrar/tests/test_models.py

@@ -668,3 +668,48 @@ class TestUser(TestCase):
             # if check_domain_invitations_on_login properly matches exactly one
             # Domain Invitation, then save routine should be called exactly once
             save_mock.assert_called_once()
+
+
+class TestContact(TestCase):
+    def setUp(self):
+        self.email = "mayor@igorville.gov"
+        self.user, _ = User.objects.get_or_create(email=self.email, first_name="Jeff", last_name="Lebowski")
+        self.contact, _ = Contact.objects.get_or_create(user=self.user)
+
+    def tearDown(self):
+        super().tearDown()
+        Contact.objects.all().delete()
+        User.objects.all().delete()
+
+    def test_saving_contact_updates_user_first_last_names(self):
+        """When a contact is updated, we propagate the changes to the linked user if it exists."""
+        # User and Contact are created and linked as expected
+        self.assertEqual(self.contact.first_name, "Jeff")
+        self.assertEqual(self.contact.last_name, "Lebowski")
+        self.assertEqual(self.user.first_name, "Jeff")
+        self.assertEqual(self.user.last_name, "Lebowski")
+
+        self.contact.first_name = "Joey"
+        self.contact.last_name = "Baloney"
+        self.contact.save()
+
+        # Refresh the user object to reflect the changes made in the database
+        self.user.refresh_from_db()
+
+        # Updating the contact's first and last names propagate to the user
+        self.assertEqual(self.contact.first_name, "Joey")
+        self.assertEqual(self.contact.last_name, "Baloney")
+        self.assertEqual(self.user.first_name, "Joey")
+        self.assertEqual(self.user.last_name, "Baloney")
+
+    def test_saving_contact_does_not_update_user_email(self):
+        """When a contact's email is updated, the change is not propagated to the lined user."""
+        self.contact.email = "joey.baloney@diaperville.com"
+        self.contact.save()
+
+        # Refresh the user object to reflect the changes made in the database
+        self.user.refresh_from_db()
+
+        # Updating the contact's email does not propagate
+        self.assertEqual(self.contact.email, "joey.baloney@diaperville.com")
+        self.assertEqual(self.user.email, "mayor@igorville.gov")

src/registrar/tests/test_transition_domain_migrations.py

@@ -18,7 +18,175 @@ from unittest.mock import patch
 
 from registrar.models.contact import Contact
 
-from .common import less_console_noise
+from .common import MockEppLib, less_console_noise
+
+
+class TestExtendExpirationDates(MockEppLib):
+    def setUp(self):
+        """Defines the file name of migration_json and the folder its contained in"""
+        super().setUp()
+        # Create a valid domain that is updatable
+        Domain.objects.get_or_create(
+            name="waterbutpurple.gov", state=Domain.State.READY, expiration_date=datetime.date(2023, 11, 15)
+        )
+        TransitionDomain.objects.get_or_create(
+            username="testytester@mail.com",
+            domain_name="waterbutpurple.gov",
+            epp_expiration_date=datetime.date(2023, 11, 15),
+        )
+        # Create a domain with an invalid expiration date
+        Domain.objects.get_or_create(
+            name="fake.gov", state=Domain.State.READY, expiration_date=datetime.date(2022, 5, 25)
+        )
+        TransitionDomain.objects.get_or_create(
+            username="themoonisactuallycheese@mail.com",
+            domain_name="fake.gov",
+            epp_expiration_date=datetime.date(2022, 5, 25),
+        )
+        # Create a domain with an invalid state
+        Domain.objects.get_or_create(
+            name="fakeneeded.gov", state=Domain.State.DNS_NEEDED, expiration_date=datetime.date(2023, 11, 15)
+        )
+        TransitionDomain.objects.get_or_create(
+            username="fakeneeded@mail.com",
+            domain_name="fakeneeded.gov",
+            epp_expiration_date=datetime.date(2023, 11, 15),
+        )
+        # Create a domain with a date greater than the maximum
+        Domain.objects.get_or_create(
+            name="fakemaximum.gov", state=Domain.State.READY, expiration_date=datetime.date(2024, 12, 31)
+        )
+        TransitionDomain.objects.get_or_create(
+            username="fakemaximum@mail.com",
+            domain_name="fakemaximum.gov",
+            epp_expiration_date=datetime.date(2024, 12, 31),
+        )
+
+    def tearDown(self):
+        """Deletes all DB objects related to migrations"""
+        super().tearDown()
+        # Delete domain information
+        Domain.objects.all().delete()
+        DomainInformation.objects.all().delete()
+        DomainInvitation.objects.all().delete()
+        TransitionDomain.objects.all().delete()
+
+        # Delete users
+        User.objects.all().delete()
+        UserDomainRole.objects.all().delete()
+
+    def run_extend_expiration_dates(self):
+        """
+        This method executes the transfer_transition_domains_to_domains command.
+
+        The 'call_command' function from Django's management framework is then used to
+        execute the load_transition_domain command with the specified arguments.
+        """
+        with patch(
+            "registrar.management.commands.utility.terminal_helper.TerminalHelper.query_yes_no_exit",  # noqa
+            return_value=True,
+        ):
+            call_command("extend_expiration_dates")
+
+    def test_extends_expiration_date_correctly(self):
+        """
+        Tests that the extend_expiration_dates method extends dates as expected
+        """
+        desired_domain = Domain.objects.filter(name="waterbutpurple.gov").get()
+        desired_domain.expiration_date = datetime.date(2024, 11, 15)
+
+        # Run the expiration date script
+        self.run_extend_expiration_dates()
+
+        current_domain = Domain.objects.filter(name="waterbutpurple.gov").get()
+
+        self.assertEqual(desired_domain, current_domain)
+        # Explicitly test the expiration date
+        self.assertEqual(current_domain.expiration_date, datetime.date(2024, 11, 15))
+
+    def test_extends_expiration_date_skips_non_current(self):
+        """
+        Tests that the extend_expiration_dates method correctly skips domains
+        with an expiration date less than a certain threshold.
+        """
+        desired_domain = Domain.objects.filter(name="fake.gov").get()
+        desired_domain.expiration_date = datetime.date(2022, 5, 25)
+
+        # Run the expiration date script
+        self.run_extend_expiration_dates()
+
+        current_domain = Domain.objects.filter(name="fake.gov").get()
+        self.assertEqual(desired_domain, current_domain)
+
+        # Explicitly test the expiration date. The extend_expiration_dates script
+        # will skip all dates less than date(2023, 11, 15), meaning that this domain
+        # should not be affected by the change.
+        self.assertEqual(current_domain.expiration_date, datetime.date(2022, 5, 25))
+
+    def test_extends_expiration_date_skips_maximum_date(self):
+        """
+        Tests that the extend_expiration_dates method correctly skips domains
+        with an expiration date more than a certain threshold.
+        """
+        desired_domain = Domain.objects.filter(name="fakemaximum.gov").get()
+        desired_domain.expiration_date = datetime.date(2024, 12, 31)
+
+        # Run the expiration date script
+        self.run_extend_expiration_dates()
+
+        current_domain = Domain.objects.filter(name="fakemaximum.gov").get()
+        self.assertEqual(desired_domain, current_domain)
+
+        # Explicitly test the expiration date. The extend_expiration_dates script
+        # will skip all dates less than date(2023, 11, 15), meaning that this domain
+        # should not be affected by the change.
+        self.assertEqual(current_domain.expiration_date, datetime.date(2024, 12, 31))
+
+    def test_extends_expiration_date_skips_non_ready(self):
+        """
+        Tests that the extend_expiration_dates method correctly skips domains not in the state "ready"
+        """
+        desired_domain = Domain.objects.filter(name="fakeneeded.gov").get()
+        desired_domain.expiration_date = datetime.date(2023, 11, 15)
+
+        # Run the expiration date script
+        self.run_extend_expiration_dates()
+
+        current_domain = Domain.objects.filter(name="fakeneeded.gov").get()
+        self.assertEqual(desired_domain, current_domain)
+
+        # Explicitly test the expiration date. The extend_expiration_dates script
+        # will skip all dates less than date(2023, 11, 15), meaning that this domain
+        # should not be affected by the change.
+        self.assertEqual(current_domain.expiration_date, datetime.date(2023, 11, 15))
+
+    def test_extends_expiration_date_idempotent(self):
+        """
+        Tests the idempotency of the extend_expiration_dates command.
+
+        Verifies that running the method multiple times does not change the expiration date
+        of a domain beyond the initial extension.
+        """
+        desired_domain = Domain.objects.filter(name="waterbutpurple.gov").get()
+        desired_domain.expiration_date = datetime.date(2024, 11, 15)
+
+        # Run the expiration date script
+        self.run_extend_expiration_dates()
+
+        current_domain = Domain.objects.filter(name="waterbutpurple.gov").get()
+        self.assertEqual(desired_domain, current_domain)
+
+        # Explicitly test the expiration date
+        self.assertEqual(desired_domain.expiration_date, datetime.date(2024, 11, 15))
+
+        # Run the expiration date script again
+        self.run_extend_expiration_dates()
+
+        # The old domain shouldn't have changed
+        self.assertEqual(desired_domain, current_domain)
+
+        # Explicitly test the expiration date - should be the same
+        self.assertEqual(desired_domain.expiration_date, datetime.date(2024, 11, 15))
 
 
 class TestProcessedMigrations(TestCase):

src/registrar/tests/test_views.py

@@ -140,7 +140,7 @@ class DomainApplicationTests(TestWithUser, WebTest):
         # 302 redirect to the first form
         page = self.app.get(reverse("application:")).follow()
         # submitting should get back the same page if the required field is empty
-        result = page.form.submit()
+        result = page.forms[0].submit()
         self.assertIn("What kind of U.S.-based government organization do you represent?", result)
 
     def test_application_multiple_applications_exist(self):
@@ -163,6 +163,9 @@ class DomainApplicationTests(TestWithUser, WebTest):
         this test work.
 
         This test also looks for the long organization name on the summary page.
+
+        This also tests for the presence of a modal trigger and the dynamic test
+        in the modal header on the submit page.
         """
         num_pages_tested = 0
         # elections, type_of_work, tribal_government, no_other_contacts
@@ -177,11 +180,11 @@ class DomainApplicationTests(TestWithUser, WebTest):
         session_id = self.app.cookies[settings.SESSION_COOKIE_NAME]
 
         # ---- TYPE PAGE  ----
-        type_form = type_page.form
+        type_form = type_page.forms[0]
         type_form["organization_type-organization_type"] = "federal"
         # test next button and validate data
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
-        type_result = type_page.form.submit()
+        type_result = type_form.submit()
         # should see results in db
         application = DomainApplication.objects.get()  # there's only one
         self.assertEqual(application.organization_type, "federal")
@@ -196,7 +199,7 @@ class DomainApplicationTests(TestWithUser, WebTest):
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
 
         federal_page = type_result.follow()
-        federal_form = federal_page.form
+        federal_form = federal_page.forms[0]
         federal_form["organization_federal-federal_type"] = "executive"
 
         # test next button
@@ -215,7 +218,7 @@ class DomainApplicationTests(TestWithUser, WebTest):
         # Follow the redirect to the next form page
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
         org_contact_page = federal_result.follow()
-        org_contact_form = org_contact_page.form
+        org_contact_form = org_contact_page.forms[0]
         # federal agency so we have to fill in federal_agency
         org_contact_form["organization_contact-federal_agency"] = "General Services Administration"
         org_contact_form["organization_contact-organization_name"] = "Testorg"
@@ -248,7 +251,7 @@ class DomainApplicationTests(TestWithUser, WebTest):
         # Follow the redirect to the next form page
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
         ao_page = org_contact_result.follow()
-        ao_form = ao_page.form
+        ao_form = ao_page.forms[0]
         ao_form["authorizing_official-first_name"] = "Testy ATO"
         ao_form["authorizing_official-last_name"] = "Tester ATO"
         ao_form["authorizing_official-title"] = "Chief Tester"
@@ -275,7 +278,7 @@ class DomainApplicationTests(TestWithUser, WebTest):
         # Follow the redirect to the next form page
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
         current_sites_page = ao_result.follow()
-        current_sites_form = current_sites_page.form
+        current_sites_form = current_sites_page.forms[0]
         current_sites_form["current_sites-0-website"] = "www.city.com"
 
         # test next button
@@ -297,7 +300,7 @@ class DomainApplicationTests(TestWithUser, WebTest):
         # Follow the redirect to the next form page
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
         dotgov_page = current_sites_result.follow()
-        dotgov_form = dotgov_page.form
+        dotgov_form = dotgov_page.forms[0]
         dotgov_form["dotgov_domain-requested_domain"] = "city"
         dotgov_form["dotgov_domain-0-alternative_domain"] = "city1"
 
@@ -317,7 +320,7 @@ class DomainApplicationTests(TestWithUser, WebTest):
         # Follow the redirect to the next form page
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
         purpose_page = dotgov_result.follow()
-        purpose_form = purpose_page.form
+        purpose_form = purpose_page.forms[0]
         purpose_form["purpose-purpose"] = "For all kinds of things."
 
         # test next button
@@ -336,7 +339,7 @@ class DomainApplicationTests(TestWithUser, WebTest):
         # Follow the redirect to the next form page
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
         your_contact_page = purpose_result.follow()
-        your_contact_form = your_contact_page.form
+        your_contact_form = your_contact_page.forms[0]
 
         your_contact_form["your_contact-first_name"] = "Testy you"
         your_contact_form["your_contact-last_name"] = "Tester you"
@@ -364,7 +367,7 @@ class DomainApplicationTests(TestWithUser, WebTest):
         # Follow the redirect to the next form page
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
         other_contacts_page = your_contact_result.follow()
-        other_contacts_form = other_contacts_page.form
+        other_contacts_form = other_contacts_page.forms[0]
 
         other_contacts_form["other_contacts-0-first_name"] = "Testy2"
         other_contacts_form["other_contacts-0-last_name"] = "Tester2"
@@ -397,7 +400,7 @@ class DomainApplicationTests(TestWithUser, WebTest):
         # 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.form
+        anything_else_form = anything_else_page.forms[0]
 
         anything_else_form["anything_else-anything_else"] = "Nothing else."
 
@@ -417,7 +420,7 @@ class DomainApplicationTests(TestWithUser, WebTest):
         # 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_form = requirements_page.form
+        requirements_form = requirements_page.forms[0]
 
         requirements_form["requirements-is_policy_acknowledged"] = True
 
@@ -437,7 +440,7 @@ class DomainApplicationTests(TestWithUser, WebTest):
         # Follow the redirect to the next form page
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
         review_page = requirements_result.follow()
-        review_form = review_page.form
+        review_form = review_page.forms[0]
 
         # Review page contains all the previously entered data
         # Let's make sure the long org name is displayed
@@ -471,6 +474,14 @@ class DomainApplicationTests(TestWithUser, WebTest):
         self.assertContains(review_page, "(201) 555-5557")
         self.assertContains(review_page, "Nothing else.")
 
+        # We can't test the modal itself as it relies on JS for init and triggering,
+        # but we can test for the existence of its trigger:
+        self.assertContains(review_page, "toggle-submit-domain-request")
+        # And the existence of the modal's data parked and ready for the js init.
+        # The next assert also tests for the passed requested domain context from
+        # the view > application_form > modal
+        self.assertContains(review_page, "You are about to submit a domain request for city.gov")
+
         # final submission results in a redirect to the "finished" URL
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
         with less_console_noise():
@@ -539,7 +550,7 @@ class DomainApplicationTests(TestWithUser, WebTest):
         # the conditional step titles shouldn't appear initially
         self.assertNotContains(type_page, self.TITLES["organization_federal"])
         self.assertNotContains(type_page, self.TITLES["organization_election"])
-        type_form = type_page.form
+        type_form = type_page.forms[0]
         type_form["organization_type-organization_type"] = "federal"
 
         # set the session ID before .submit()
@@ -560,9 +571,9 @@ class DomainApplicationTests(TestWithUser, WebTest):
 
         # continuing on in the flow we need to see top-level agency on the
         # contact page
-        federal_page.form["organization_federal-federal_type"] = "executive"
+        federal_page.forms[0]["organization_federal-federal_type"] = "executive"
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
-        federal_result = federal_page.form.submit()
+        federal_result = federal_page.forms[0].submit()
         # the post request should return a redirect to the contact
         # question
         self.assertEqual(federal_result.status_code, 302)
@@ -585,7 +596,7 @@ class DomainApplicationTests(TestWithUser, WebTest):
         # the conditional step titles shouldn't appear initially
         self.assertNotContains(type_page, self.TITLES["organization_federal"])
         self.assertNotContains(type_page, self.TITLES["organization_election"])
-        type_form = type_page.form
+        type_form = type_page.forms[0]
         type_form["organization_type-organization_type"] = "county"
 
         # set the session ID before .submit()
@@ -605,9 +616,9 @@ class DomainApplicationTests(TestWithUser, WebTest):
 
         # continuing on in the flow we need to NOT see top-level agency on the
         # contact page
-        election_page.form["organization_election-is_election_board"] = "True"
+        election_page.forms[0]["organization_election-is_election_board"] = "True"
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
-        election_result = election_page.form.submit()
+        election_result = election_page.forms[0].submit()
         # the post request should return a redirect to the contact
         # question
         self.assertEqual(election_result.status_code, 302)
@@ -625,10 +636,10 @@ class DomainApplicationTests(TestWithUser, WebTest):
         # and then setting the cookie on each request.
         session_id = self.app.cookies[settings.SESSION_COOKIE_NAME]
 
-        type_form = type_page.form
+        type_form = type_page.forms[0]
         type_form["organization_type-organization_type"] = "federal"
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
-        type_result = type_page.form.submit()
+        type_result = type_form.submit()
 
         # follow first redirect
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
@@ -653,15 +664,15 @@ class DomainApplicationTests(TestWithUser, WebTest):
         # and then setting the cookie on each request.
         session_id = self.app.cookies[settings.SESSION_COOKIE_NAME]
 
-        type_form = type_page.form
+        type_form = type_page.forms[0]
         type_form["organization_type-organization_type"] = DomainApplication.OrganizationChoices.INTERSTATE
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
-        type_result = type_page.form.submit()
+        type_result = type_form.submit()
 
         # follow first redirect
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
         contact_page = type_result.follow()
-        org_contact_form = contact_page.form
+        org_contact_form = contact_page.forms[0]
 
         self.assertNotIn("federal_agency", org_contact_form.fields)
 
@@ -689,10 +700,10 @@ class DomainApplicationTests(TestWithUser, WebTest):
         # and then setting the cookie on each request.
         session_id = self.app.cookies[settings.SESSION_COOKIE_NAME]
 
-        type_form = type_page.form
+        type_form = type_page.forms[0]
         type_form["organization_type-organization_type"] = DomainApplication.OrganizationChoices.SPECIAL_DISTRICT
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
-        type_result = type_page.form.submit()
+        type_result = type_page.forms[0].submit()
         # follow first redirect
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
         contact_page = type_result.follow()
@@ -709,7 +720,7 @@ class DomainApplicationTests(TestWithUser, WebTest):
         session_id = self.app.cookies[settings.SESSION_COOKIE_NAME]
 
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
-        result = contacts_page.form.submit()
+        result = contacts_page.forms[0].submit()
         # follow first redirect
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
         no_contacts_page = result.follow()
@@ -726,10 +737,10 @@ class DomainApplicationTests(TestWithUser, WebTest):
         # and then setting the cookie on each request.
         session_id = self.app.cookies[settings.SESSION_COOKIE_NAME]
 
-        type_form = type_page.form
+        type_form = type_page.forms[0]
         type_form["organization_type-organization_type"] = DomainApplication.OrganizationChoices.INTERSTATE
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
-        type_result = type_page.form.submit()
+        type_result = type_form.submit()
         # follow first redirect
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
         contact_page = type_result.follow()
@@ -744,10 +755,10 @@ class DomainApplicationTests(TestWithUser, WebTest):
         # 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]
-        type_form = type_page.form
+        type_form = type_page.forms[0]
         type_form["organization_type-organization_type"] = DomainApplication.OrganizationChoices.TRIBAL
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
-        type_result = type_page.form.submit()
+        type_result = type_form.submit()
         # the tribal government page comes immediately afterwards
         self.assertIn("/tribal_government", type_result.headers["Location"])
         # follow first redirect
@@ -766,18 +777,18 @@ class DomainApplicationTests(TestWithUser, WebTest):
         session_id = self.app.cookies[settings.SESSION_COOKIE_NAME]
 
         # ---- TYPE PAGE  ----
-        type_form = type_page.form
+        type_form = type_page.forms[0]
         type_form["organization_type-organization_type"] = "federal"
 
         # test next button
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
-        type_result = type_page.form.submit()
+        type_result = type_form.submit()
 
         # ---- FEDERAL BRANCH PAGE  ----
         # Follow the redirect to the next form page
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
         federal_page = type_result.follow()
-        federal_form = federal_page.form
+        federal_form = federal_page.forms[0]
         federal_form["organization_federal-federal_type"] = "executive"
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
         federal_result = federal_form.submit()
@@ -786,7 +797,7 @@ class DomainApplicationTests(TestWithUser, WebTest):
         # Follow the redirect to the next form page
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
         org_contact_page = federal_result.follow()
-        org_contact_form = org_contact_page.form
+        org_contact_form = org_contact_page.forms[0]
         # federal agency so we have to fill in federal_agency
         org_contact_form["organization_contact-federal_agency"] = "General Services Administration"
         org_contact_form["organization_contact-organization_name"] = "Testorg"
@@ -827,18 +838,18 @@ class DomainApplicationTests(TestWithUser, WebTest):
         # and then setting the cookie on each request.
         session_id = self.app.cookies[settings.SESSION_COOKIE_NAME]
         # ---- TYPE PAGE  ----
-        type_form = type_page.form
+        type_form = type_page.forms[0]
         type_form["organization_type-organization_type"] = "federal"
 
         # test next button
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
-        type_result = type_page.form.submit()
+        type_result = type_form.submit()
 
         # ---- FEDERAL BRANCH PAGE  ----
         # Follow the redirect to the next form page
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
         federal_page = type_result.follow()
-        federal_form = federal_page.form
+        federal_form = federal_page.forms[0]
         federal_form["organization_federal-federal_type"] = "executive"
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
         federal_result = federal_form.submit()
@@ -847,7 +858,7 @@ class DomainApplicationTests(TestWithUser, WebTest):
         # Follow the redirect to the next form page
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
         org_contact_page = federal_result.follow()
-        org_contact_form = org_contact_page.form
+        org_contact_form = org_contact_page.forms[0]
         # federal agency so we have to fill in federal_agency
         org_contact_form["organization_contact-federal_agency"] = "General Services Administration"
         org_contact_form["organization_contact-organization_name"] = "Testorg"
@@ -869,7 +880,7 @@ class DomainApplicationTests(TestWithUser, WebTest):
         # Follow the redirect to the next form page
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
         ao_page = org_contact_result.follow()
-        ao_form = ao_page.form
+        ao_form = ao_page.forms[0]
         ao_form["authorizing_official-first_name"] = "Testy ATO"
         ao_form["authorizing_official-last_name"] = "Tester ATO"
         ao_form["authorizing_official-title"] = "Chief Tester"
@@ -883,7 +894,7 @@ class DomainApplicationTests(TestWithUser, WebTest):
         # Follow the redirect to the next form page
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
         current_sites_page = ao_result.follow()
-        current_sites_form = current_sites_page.form
+        current_sites_form = current_sites_page.forms[0]
         current_sites_form["current_sites-0-website"] = "www.city.com"
 
         # test saving the page
@@ -916,7 +927,7 @@ class DomainApplicationTests(TestWithUser, WebTest):
         current_sites_page = self.app.get(reverse("application:current_sites"))
         session_id = self.app.cookies[settings.SESSION_COOKIE_NAME]
         # fill in the form field
-        current_sites_form = current_sites_page.form
+        current_sites_form = current_sites_page.forms[0]
         self.assertIn("current_sites-0-website", current_sites_form.fields)
         self.assertNotIn("current_sites-1-website", current_sites_form.fields)
         current_sites_form["current_sites-0-website"] = "https://example.com"
@@ -925,7 +936,7 @@ class DomainApplicationTests(TestWithUser, WebTest):
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
         current_sites_result = current_sites_form.submit("submit_button", value="save")
         self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
-        current_sites_form = current_sites_result.follow().form
+        current_sites_form = current_sites_result.follow().forms[0]
 
         # verify that there are two form fields
         value = current_sites_form["current_sites-0-website"].value
@@ -1085,6 +1096,18 @@ class DomainApplicationTests(TestWithUser, WebTest):
         detail_page = home_page.click("Manage", index=0)
         self.assertContains(detail_page, "Federal: an agency of the U.S. government")
 
+    def test_submit_modal_no_domain_text_fallback(self):
+        """When user clicks on submit your domain request and the requested domain
+        is null (possible through url direct access to the review page), present
+        fallback copy in the modal's header.
+
+        NOTE: This may be a moot point if we implement a more solid pattern in the
+        future, like not a submit action at all on the review page."""
+
+        review_page = self.app.get(reverse("application:review"))
+        self.assertContains(review_page, "toggle-submit-domain-request")
+        self.assertContains(review_page, "You are about to submit an incomplete request")
+
 
 class TestWithDomainPermissions(TestWithUser):
     def setUp(self):

src/registrar/utility/errors.py

@@ -43,11 +43,11 @@ class GenericError(Exception):
     """
 
     _error_mapping = {
-        GenericErrorCodes.CANNOT_CONTACT_REGISTRY: """
-We’re experiencing a system connection error. Please wait a few minutes
-and try again. If you continue to receive this error after a few tries,
-contact help@get.gov.
-        """,
+        GenericErrorCodes.CANNOT_CONTACT_REGISTRY: (
+            "We’re experiencing a system connection error. Please wait a few minutes "
+            "and try again. If you continue to receive this error after a few tries, "
+            "contact help@get.gov."
+        ),
         GenericErrorCodes.GENERIC_ERROR: ("Value entered was wrong."),
     }
 

src/registrar/views/application.py

@@ -321,12 +321,21 @@ class ApplicationWizard(ApplicationWizardPermissionView, TemplateView):
 
     def get_context_data(self):
         """Define context for access on all wizard pages."""
+        # Build the submit button that we'll pass to the modal.
+        modal_button = '<button type="submit" ' 'class="usa-button" ' ">Submit request</button>"
+        # Concatenate the modal header that we'll pass to the modal.
+        if self.application.requested_domain:
+            modal_heading = "You are about to submit a domain request for " + str(self.application.requested_domain)
+        else:
+            modal_heading = "You are about to submit an incomplete request"
         return {
             "form_titles": self.TITLES,
             "steps": self.steps,
             # Add information about which steps should be unlocked
             "visited": self.storage.get("step_history", []),
             "is_federal": self.application.is_federal(),
+            "modal_button": modal_button,
+            "modal_heading": modal_heading,
         }
 
     def get_step_list(self) -> list: