revisions

src/registrar/fixtures/fixtures_domains.py

@@ -56,10 +56,10 @@ class DomainFixture(DomainRequestFixture):
         return current_date + timedelta(days=random.randint(-365, -1))  # nosec
 
     @classmethod
-    def _approve_request(cls, domain_request, users, is_expired=False):
+    def _approve_request(cls, domain_request, users):
-        """Helper function to approve a domain request and set expiration dates."""
+        """Helper function to approve a domain request."""
         if not domain_request:
-            return None, None
+            return None
 
         if domain_request.investigator is None:
             # Assign random investigator if not already assigned
@@ -68,21 +68,13 @@ class DomainFixture(DomainRequestFixture):
         # Approve the domain request
         domain_request.approve(send_email=False)
 
-        # Set expiration date for domain
+        return domain_request
-        domain = None
-        if domain_request.requested_domain:
-            domain, _ = Domain.objects.get_or_create(name=domain_request.requested_domain.name)
-            domain.expiration_date = (
-                cls._generate_fake_expiration_date_in_past() if is_expired else cls._generate_fake_expiration_date()
-            )
-
-        return domain
 
     @classmethod
     def _approve_domain_requests(cls, users):
         """Approves one current and one expired request per user."""
         domain_requests_to_update = []
-        domains_to_update = []
+        expired_requests = []
 
         for user in users:
             # Get the latest and second-to-last domain requests
@@ -95,22 +87,34 @@ class DomainFixture(DomainRequestFixture):
             # Second-to-last domain request (expired)
             domain_request_expired = domain_requests[1] if len(domain_requests) > 1 else None
 
-            # Approve the current and expired domain requests
+            # Approve the current domain request
-            approved_domain = cls._approve_request(domain_request, users)
-            expired_domain = cls._approve_request(domain_request_expired, users, is_expired=True)
-
-            # Collect objects to update
             if domain_request:
+                cls._approve_request(domain_request, users)
                 domain_requests_to_update.append(domain_request)
-            if domain_request_expired:
-                domain_requests_to_update.append(domain_request_expired)
-            if approved_domain:
-                domains_to_update.append(approved_domain)
-            if expired_domain:
-                domains_to_update.append(expired_domain)
 
-        # Perform bulk updates
+            # Approve the expired domain request
+            if domain_request_expired:
+                cls._approve_request(domain_request_expired, users)
+                domain_requests_to_update.append(domain_request_expired)
+                expired_requests.append(domain_request_expired)
+
+        # Perform bulk update for the domain requests
         cls._bulk_update_requests(domain_requests_to_update)
+
+        # Retrieve all domains associated with the domain requests
+        domains_to_update = Domain.objects.filter(domain_info__domain_request__in=domain_requests_to_update)
+
+        # Loop through and update expiration dates for domains
+        for domain in domains_to_update:
+            domain_request = domain.domain_info.domain_request
+
+            # Set the expiration date based on whether the request is expired
+            if domain_request in expired_requests:
+                domain.expiration_date = cls._generate_fake_expiration_date_in_past()
+            else:
+                domain.expiration_date = cls._generate_fake_expiration_date()
+
+        # Perform bulk update for the domains
         cls._bulk_update_domains(domains_to_update)
 
     @classmethod

src/registrar/fixtures/fixtures_portfolios.py

@@ -67,13 +67,13 @@ class PortfolioFixture:
     def _set_foreign_key_fields(cls, portfolio: Portfolio, portfolio_dict: dict, user: User):
         """Helper method used by `load`."""
         if not portfolio.senior_official:
-            if "senior_official" in portfolio_dict and portfolio_dict["senior_official"] is not None:
+            if portfolio_dict.get("senior_official") is not None:
                 portfolio.senior_official, _ = SeniorOfficial.objects.get_or_create(**portfolio_dict["senior_official"])
             else:
                 portfolio.senior_official = SeniorOfficial.objects.create(**cls.fake_so())
 
         if not portfolio.federal_agency:
-            if "federal_agency" in portfolio_dict and portfolio_dict["federal_agency"] is not None:
+            if portfolio_dict.get("federal_agency") is not None:
                 portfolio.federal_agency, _ = FederalAgency.objects.get_or_create(name=portfolio_dict["federal_agency"])
             else:
                 federal_agencies = FederalAgency.objects.all()

src/registrar/fixtures/fixtures_requests.py

@@ -5,6 +5,7 @@ import random
 from faker import Faker
 from django.db import transaction
 
+from registrar.fixtures.fixtures_portfolios import PortfolioFixture
 from registrar.fixtures.fixtures_users import UserFixture
 from registrar.models import User, DomainRequest, DraftDomain, Contact, Website, FederalAgency
 from registrar.models.portfolio import Portfolio
@@ -218,8 +219,10 @@ class DomainRequestFixture:
     @classmethod
     def _get_random_portfolio(cls):
         try:
+            organization_names = [portfolio["organization_name"] for portfolio in PortfolioFixture.PORTFOLIOS]
+
             portfolio_options = Portfolio.objects.filter(
-                organization_name__in=["Hotel California", "Wish You Were Here"]
+                organization_name__in=organization_names
             )
             return random.choice(portfolio_options) if portfolio_options.exists() else None  # nosec
         except Exception as e:

src/registrar/fixtures/fixtures_user_portfolio_permissions.py

@@ -2,6 +2,7 @@ import logging
 from faker import Faker
 from django.db import transaction
 
+from registrar.fixtures.fixtures_portfolios import PortfolioFixture
 from registrar.fixtures.fixtures_users import UserFixture
 from registrar.models import User
 from registrar.models.portfolio import Portfolio
@@ -32,8 +33,10 @@ class UserPortfolioPermissionFixture:
                 # Filter users to only include those created by the fixture
                 users = list(User.objects.filter(username__in=created_usernames))
 
+                organization_names = [portfolio["organization_name"] for portfolio in PortfolioFixture.PORTFOLIOS]
+
                 portfolios = list(
-                    Portfolio.objects.filter(organization_name__in=["Hotel California", "Wish You Were Here"])
+                    Portfolio.objects.filter(organization_name__in=organization_names)
                 )
 
                 if not users: