- |
+ |
{{ invitation.email }}
|
{{ invitation.created_at|date }} |
diff --git a/src/registrar/tests/common.py b/src/registrar/tests/common.py
index b0f920bfd..fe41647f9 100644
--- a/src/registrar/tests/common.py
+++ b/src/registrar/tests/common.py
@@ -548,17 +548,29 @@ class MockEppLib(TestCase):
class fakedEppObject(object):
""""""
- def __init__(self, auth_info=..., cr_date=..., contacts=..., hosts=...):
+ def __init__(
+ self,
+ auth_info=...,
+ cr_date=...,
+ contacts=...,
+ hosts=...,
+ statuses=...,
+ ):
self.auth_info = auth_info
self.cr_date = cr_date
self.contacts = contacts
self.hosts = hosts
+ self.statuses = statuses
mockDataInfoDomain = fakedEppObject(
"fakepw",
cr_date=datetime.datetime(2023, 5, 25, 19, 45, 35),
contacts=[common.DomainContact(contact="123", type="security")],
hosts=["fake.host.com"],
+ statuses=[
+ common.Status(state="serverTransferProhibited", description="", lang="en"),
+ common.Status(state="inactive", description="", lang="en"),
+ ],
)
infoDomainNoContact = fakedEppObject(
"security",
diff --git a/src/registrar/tests/test_admin.py b/src/registrar/tests/test_admin.py
index b28a5dcec..9ff9ce451 100644
--- a/src/registrar/tests/test_admin.py
+++ b/src/registrar/tests/test_admin.py
@@ -1,5 +1,7 @@
from django.test import TestCase, RequestFactory, Client
from django.contrib.admin.sites import AdminSite
+from contextlib import ExitStack
+from django.contrib import messages
from django.urls import reverse
from registrar.admin import (
@@ -535,7 +537,160 @@ class TestDomainApplicationAdmin(TestCase):
"Cannot edit an application with a restricted creator.",
)
+ def test_error_when_saving_approved_to_rejected_and_domain_is_active(self):
+ # Create an instance of the model
+ application = completed_application(status=DomainApplication.APPROVED)
+ domain = Domain.objects.create(name=application.requested_domain.name)
+ application.approved_domain = domain
+ application.save()
+
+ # Create a request object with a superuser
+ request = self.factory.post(
+ "/admin/registrar/domainapplication/{}/change/".format(application.pk)
+ )
+ request.user = self.superuser
+
+ # Define a custom implementation for is_active
+ def custom_is_active(self):
+ return True # Override to return True
+
+ # Use ExitStack to combine patch contexts
+ with ExitStack() as stack:
+ # Patch Domain.is_active and django.contrib.messages.error simultaneously
+ stack.enter_context(patch.object(Domain, "is_active", custom_is_active))
+ stack.enter_context(patch.object(messages, "error"))
+
+ # Simulate saving the model
+ application.status = DomainApplication.REJECTED
+ self.admin.save_model(request, application, None, True)
+
+ # Assert that the error message was called with the correct argument
+ messages.error.assert_called_once_with(
+ request,
+ "This action is not permitted. The domain " + "is already active.",
+ )
+
+ def test_side_effects_when_saving_approved_to_rejected(self):
+ # Create an instance of the model
+ application = completed_application(status=DomainApplication.APPROVED)
+ domain = Domain.objects.create(name=application.requested_domain.name)
+ domain_information = DomainInformation.objects.create(
+ creator=self.superuser, domain=domain
+ )
+ application.approved_domain = domain
+ application.save()
+
+ # Create a request object with a superuser
+ request = self.factory.post(
+ "/admin/registrar/domainapplication/{}/change/".format(application.pk)
+ )
+ request.user = self.superuser
+
+ # Define a custom implementation for is_active
+ def custom_is_active(self):
+ return False # Override to return False
+
+ # Use ExitStack to combine patch contexts
+ with ExitStack() as stack:
+ # Patch Domain.is_active and django.contrib.messages.error simultaneously
+ stack.enter_context(patch.object(Domain, "is_active", custom_is_active))
+ stack.enter_context(patch.object(messages, "error"))
+
+ # Simulate saving the model
+ application.status = DomainApplication.REJECTED
+ self.admin.save_model(request, application, None, True)
+
+ # Assert that the error message was never called
+ messages.error.assert_not_called()
+
+ self.assertEqual(application.approved_domain, None)
+
+ # Assert that Domain got Deleted
+ with self.assertRaises(Domain.DoesNotExist):
+ domain.refresh_from_db()
+
+ # Assert that DomainInformation got Deleted
+ with self.assertRaises(DomainInformation.DoesNotExist):
+ domain_information.refresh_from_db()
+
+ def test_error_when_saving_approved_to_ineligible_and_domain_is_active(self):
+ # Create an instance of the model
+ application = completed_application(status=DomainApplication.APPROVED)
+ domain = Domain.objects.create(name=application.requested_domain.name)
+ application.approved_domain = domain
+ application.save()
+
+ # Create a request object with a superuser
+ request = self.factory.post(
+ "/admin/registrar/domainapplication/{}/change/".format(application.pk)
+ )
+ request.user = self.superuser
+
+ # Define a custom implementation for is_active
+ def custom_is_active(self):
+ return True # Override to return True
+
+ # Use ExitStack to combine patch contexts
+ with ExitStack() as stack:
+ # Patch Domain.is_active and django.contrib.messages.error simultaneously
+ stack.enter_context(patch.object(Domain, "is_active", custom_is_active))
+ stack.enter_context(patch.object(messages, "error"))
+
+ # Simulate saving the model
+ application.status = DomainApplication.INELIGIBLE
+ self.admin.save_model(request, application, None, True)
+
+ # Assert that the error message was called with the correct argument
+ messages.error.assert_called_once_with(
+ request,
+ "This action is not permitted. The domain " + "is already active.",
+ )
+
+ def test_side_effects_when_saving_approved_to_ineligible(self):
+ # Create an instance of the model
+ application = completed_application(status=DomainApplication.APPROVED)
+ domain = Domain.objects.create(name=application.requested_domain.name)
+ domain_information = DomainInformation.objects.create(
+ creator=self.superuser, domain=domain
+ )
+ application.approved_domain = domain
+ application.save()
+
+ # Create a request object with a superuser
+ request = self.factory.post(
+ "/admin/registrar/domainapplication/{}/change/".format(application.pk)
+ )
+ request.user = self.superuser
+
+ # Define a custom implementation for is_active
+ def custom_is_active(self):
+ return False # Override to return False
+
+ # Use ExitStack to combine patch contexts
+ with ExitStack() as stack:
+ # Patch Domain.is_active and django.contrib.messages.error simultaneously
+ stack.enter_context(patch.object(Domain, "is_active", custom_is_active))
+ stack.enter_context(patch.object(messages, "error"))
+
+ # Simulate saving the model
+ application.status = DomainApplication.INELIGIBLE
+ self.admin.save_model(request, application, None, True)
+
+ # Assert that the error message was never called
+ messages.error.assert_not_called()
+
+ self.assertEqual(application.approved_domain, None)
+
+ # Assert that Domain got Deleted
+ with self.assertRaises(Domain.DoesNotExist):
+ domain.refresh_from_db()
+
+ # Assert that DomainInformation got Deleted
+ with self.assertRaises(DomainInformation.DoesNotExist):
+ domain_information.refresh_from_db()
+
def tearDown(self):
+ Domain.objects.all().delete()
DomainInformation.objects.all().delete()
DomainApplication.objects.all().delete()
User.objects.all().delete()
@@ -632,6 +787,7 @@ class MyUserAdminTest(TestCase):
"last_name",
"is_staff",
"is_superuser",
+ "status",
)
self.assertEqual(list_display, expected_list_display)
@@ -648,7 +804,12 @@ class MyUserAdminTest(TestCase):
request = self.client.request().wsgi_request
request.user = create_user()
fieldsets = self.admin.get_fieldsets(request)
- expected_fieldsets = ((None, {"fields": []}),)
+ expected_fieldsets = (
+ (None, {"fields": ("password", "status")}),
+ ("Personal Info", {"fields": ("first_name", "last_name", "email")}),
+ ("Permissions", {"fields": ("is_active", "is_staff", "is_superuser")}),
+ ("Important dates", {"fields": ("last_login", "date_joined")}),
+ )
self.assertEqual(fieldsets, expected_fieldsets)
def tearDown(self):
diff --git a/src/registrar/tests/test_models.py b/src/registrar/tests/test_models.py
index ca1191061..2c6f78ef5 100644
--- a/src/registrar/tests/test_models.py
+++ b/src/registrar/tests/test_models.py
@@ -1,5 +1,6 @@
from django.test import TestCase
from django.db.utils import IntegrityError
+from unittest.mock import patch
from registrar.models import (
Contact,
@@ -439,7 +440,26 @@ class TestDomainApplication(TestCase):
application = completed_application(status=DomainApplication.INELIGIBLE)
with self.assertRaises(TransitionNotAllowed):
- application.reject_with_prejudice()
+ application.reject()
+
+ def test_transition_not_allowed_approved_rejected_when_domain_is_active(self):
+ """Create an application with status approved, create a matching domain that
+ is active, and call reject against transition rules"""
+
+ application = completed_application(status=DomainApplication.APPROVED)
+ domain = Domain.objects.create(name=application.requested_domain.name)
+ application.approved_domain = domain
+ application.save()
+
+ # Define a custom implementation for is_active
+ def custom_is_active(self):
+ return True # Override to return True
+
+ # Use patch to temporarily replace is_active with the custom implementation
+ with patch.object(Domain, "is_active", custom_is_active):
+ # Now, when you call is_active on Domain, it will return True
+ with self.assertRaises(TransitionNotAllowed):
+ application.reject()
def test_transition_not_allowed_started_ineligible(self):
"""Create an application with status started and call reject
@@ -495,6 +515,25 @@ class TestDomainApplication(TestCase):
with self.assertRaises(TransitionNotAllowed):
application.reject_with_prejudice()
+ def test_transition_not_allowed_approved_ineligible_when_domain_is_active(self):
+ """Create an application with status approved, create a matching domain that
+ is active, and call reject_with_prejudice against transition rules"""
+
+ application = completed_application(status=DomainApplication.APPROVED)
+ domain = Domain.objects.create(name=application.requested_domain.name)
+ application.approved_domain = domain
+ application.save()
+
+ # Define a custom implementation for is_active
+ def custom_is_active(self):
+ return True # Override to return True
+
+ # Use patch to temporarily replace is_active with the custom implementation
+ with patch.object(Domain, "is_active", custom_is_active):
+ # Now, when you call is_active on Domain, it will return True
+ with self.assertRaises(TransitionNotAllowed):
+ application.reject_with_prejudice()
+
class TestPermissions(TestCase):
diff --git a/src/registrar/tests/test_models_domain.py b/src/registrar/tests/test_models_domain.py
index 9aaac7321..d35b0ba96 100644
--- a/src/registrar/tests/test_models_domain.py
+++ b/src/registrar/tests/test_models_domain.py
@@ -34,6 +34,8 @@ class TestDomainCache(MockEppLib):
# (see InfoDomainResult)
self.assertEquals(domain._cache["auth_info"], self.mockDataInfoDomain.auth_info)
self.assertEquals(domain._cache["cr_date"], self.mockDataInfoDomain.cr_date)
+ status_list = [status.state for status in self.mockDataInfoDomain.statuses]
+ self.assertEquals(domain._cache["statuses"], status_list)
self.assertFalse("avail" in domain._cache.keys())
# using a setter should clear the cache
@@ -49,7 +51,8 @@ class TestDomainCache(MockEppLib):
),
call(commands.InfoContact(id="123", auth_info=None), cleaned=True),
call(commands.InfoHost(name="fake.host.com"), cleaned=True),
- ]
+ ],
+ any_order=False, # Ensure calls are in the specified order
)
def test_cache_used_when_avail(self):
@@ -106,16 +109,14 @@ class TestDomainCache(MockEppLib):
domain._get_property("hosts")
self.assertEqual(domain._cache["hosts"], [expectedHostsDict])
+ def tearDown(self) -> None:
+ Domain.objects.all().delete()
+ super().tearDown()
-class TestDomainCreation(TestCase):
+
+class TestDomainCreation(MockEppLib):
"""Rule: An approved domain application must result in a domain"""
- def setUp(self):
- """
- Background:
- Given that a valid domain application exists
- """
-
def test_approved_application_creates_domain_locally(self):
"""
Scenario: Analyst approves a domain application
@@ -123,8 +124,6 @@ class TestDomainCreation(TestCase):
Then a Domain exists in the database with the same `name`
But a domain object does not exist in the registry
"""
- patcher = patch("registrar.models.domain.Domain._get_or_create_domain")
- mocked_domain_creation = patcher.start()
draft_domain, _ = DraftDomain.objects.get_or_create(name="igorville.gov")
user, _ = User.objects.get_or_create()
application = DomainApplication.objects.create(
@@ -137,19 +136,46 @@ class TestDomainCreation(TestCase):
# should hav information present for this domain
domain = Domain.objects.get(name="igorville.gov")
self.assertTrue(domain)
- mocked_domain_creation.assert_not_called()
+ self.mockedSendFunction.assert_not_called()
- @skip("not implemented yet")
def test_accessing_domain_properties_creates_domain_in_registry(self):
"""
Scenario: A registrant checks the status of a newly approved domain
Given that no domain object exists in the registry
When a property is accessed
Then Domain sends `commands.CreateDomain` to the registry
- And `domain.state` is set to `CREATED`
+ And `domain.state` is set to `UNKNOWN`
And `domain.is_active()` returns False
"""
- raise
+ domain = Domain.objects.create(name="beef-tongue.gov")
+ # trigger getter
+ _ = domain.statuses
+
+ # contacts = PublicContact.objects.filter(domain=domain,
+ # type=PublicContact.ContactTypeChoices.REGISTRANT).get()
+
+ # Called in _fetch_cache
+ self.mockedSendFunction.assert_has_calls(
+ [
+ # TODO: due to complexity of the test, will return to it in
+ # a future ticket
+ # call(
+ # commands.CreateDomain(name="beef-tongue.gov",
+ # id=contact.registry_id, auth_info=None),
+ # cleaned=True,
+ # ),
+ call(
+ commands.InfoDomain(name="beef-tongue.gov", auth_info=None),
+ cleaned=True,
+ ),
+ call(commands.InfoContact(id="123", auth_info=None), cleaned=True),
+ call(commands.InfoHost(name="fake.host.com"), cleaned=True),
+ ],
+ any_order=False, # Ensure calls are in the specified order
+ )
+
+ self.assertEqual(domain.state, Domain.State.UNKNOWN)
+ self.assertEqual(domain.is_active(), False)
@skip("assertion broken with mock addition")
def test_empty_domain_creation(self):
@@ -168,20 +194,71 @@ class TestDomainCreation(TestCase):
with self.assertRaisesRegex(IntegrityError, "name"):
Domain.objects.create(name="igorville.gov")
- @skip("cannot activate a domain without mock registry")
- def test_get_status(self):
- """Returns proper status based on `state`."""
- domain = Domain.objects.create(name="igorville.gov")
- domain.save()
- self.assertEqual(None, domain.status)
- domain.activate()
- domain.save()
- self.assertIn("ok", domain.status)
-
def tearDown(self) -> None:
DomainInformation.objects.all().delete()
DomainApplication.objects.all().delete()
Domain.objects.all().delete()
+ super().tearDown()
+
+
+class TestDomainStatuses(MockEppLib):
+ """Domain statuses are set by the registry"""
+
+ def test_get_status(self):
+ """Domain 'statuses' getter returns statuses by calling epp"""
+ domain, _ = Domain.objects.get_or_create(name="chicken-liver.gov")
+ # trigger getter
+ _ = domain.statuses
+ status_list = [status.state for status in self.mockDataInfoDomain.statuses]
+ self.assertEquals(domain._cache["statuses"], status_list)
+
+ # Called in _fetch_cache
+ self.mockedSendFunction.assert_has_calls(
+ [
+ call(
+ commands.InfoDomain(name="chicken-liver.gov", auth_info=None),
+ cleaned=True,
+ ),
+ call(commands.InfoContact(id="123", auth_info=None), cleaned=True),
+ call(commands.InfoHost(name="fake.host.com"), cleaned=True),
+ ],
+ any_order=False, # Ensure calls are in the specified order
+ )
+
+ def test_get_status_returns_empty_list_when_value_error(self):
+ """Domain 'statuses' getter returns an empty list
+ when value error"""
+ domain, _ = Domain.objects.get_or_create(name="pig-knuckles.gov")
+
+ def side_effect(self):
+ raise KeyError
+
+ patcher = patch("registrar.models.domain.Domain._get_property")
+ mocked_get = patcher.start()
+ mocked_get.side_effect = side_effect
+
+ # trigger getter
+ _ = domain.statuses
+
+ with self.assertRaises(KeyError):
+ _ = domain._cache["statuses"]
+ self.assertEquals(_, [])
+
+ patcher.stop()
+
+ @skip("not implemented yet")
+ def test_place_client_hold_sets_status(self):
+ """Domain 'place_client_hold' method causes the registry to change statuses"""
+ raise
+
+ @skip("not implemented yet")
+ def test_revert_client_hold_sets_status(self):
+ """Domain 'revert_client_hold' method causes the registry to change statuses"""
+ raise
+
+ def tearDown(self) -> None:
+ Domain.objects.all().delete()
+ super().tearDown()
class TestRegistrantContacts(MockEppLib):