zydronium/manage.get.gov
1
0
Fork 0
mirror of https://github.com/cisagov/manage.get.gov.git synced 2025-05-16 09:37:03 +02:00
Code Issues Projects Releases Packages Wiki Activity

change first_ready_at and deleted_at to first_ready and deleted

Browse source
This commit is contained in:
Rachid Mrad 2023-12-29 12:05:49 -05:00
parent 0ce04007ff
commit 72edec8362
No known key found for this signature in database
GPG key ID: EF38E4CEC4A8F3CF
6 changed files with 57 additions and 57 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/registrar/admin.py
View file

@ -985,8 +985,8 @@ class DomainAdmin(ListHeaderAdmin):
"state", "state",
"expiration_date", "expiration_date",
"created_at", "created_at",
"first_ready_at", "first_ready",
"deleted_at", "deleted",
] ]
# this ordering effects the ordering of results # this ordering effects the ordering of results
@ -1005,7 +1005,7 @@ class DomainAdmin(ListHeaderAdmin):
search_help_text = "Search by domain name." search_help_text = "Search by domain name."
change_form_template = "django/admin/domain_change_form.html" change_form_template = "django/admin/domain_change_form.html"
change_list_template = "django/admin/domain_change_list.html" change_list_template = "django/admin/domain_change_list.html"
readonly_fields = ["state", "expiration_date", "first_ready_at", "deleted_at"] readonly_fields = ["state", "expiration_date", "first_ready", "deleted"]
# Table ordering # Table ordering
ordering = ["name"] ordering = ["name"]

4
src/registrar/migrations/0059_domain_deleted_at_domain_first_ready_at.py → src/registrar/migrations/0059_domain_deleted_domain_first_ready.py
View file

@ -11,12 +11,12 @@ class Migration(migrations.Migration):
operations = [ operations = [
migrations.AddField( migrations.AddField(
model_name="domain", model_name="domain",
name="deleted_at", name="deleted",
field=models.DateField(editable=False, help_text="Deleted at date", null=True), field=models.DateField(editable=False, help_text="Deleted at date", null=True),
), ),
migrations.AddField( migrations.AddField(
model_name="domain", model_name="domain",
name="first_ready_at", name="first_ready",
field=models.DateField( field=models.DateField(
editable=False, help_text="The last time this domain moved into the READY state", null=True editable=False, help_text="The last time this domain moved into the READY state", null=True
), ),

14
src/registrar/models/domain.py
View file

@ -969,13 +969,13 @@ class Domain(TimeStampedModel, DomainHelper):
help_text=("Duplication of registry's expiration date saved for ease of reporting"), help_text=("Duplication of registry's expiration date saved for ease of reporting"),
) )
deleted_at = DateField( deleted = DateField(
null=True, null=True,
editable=False, editable=False,
help_text="Deleted at date", help_text="Deleted at date",
) )
first_ready_at = DateField( first_ready = DateField(
null=True, null=True,
editable=False, editable=False,
help_text="The last time this domain moved into the READY state", help_text="The last time this domain moved into the READY state",
@ -1310,7 +1310,7 @@ class Domain(TimeStampedModel, DomainHelper):
try: try:
logger.info("deletedInEpp()-> inside _delete_domain") logger.info("deletedInEpp()-> inside _delete_domain")
self._delete_domain() self._delete_domain()
self.deleted_at = timezone.now() self.deleted = timezone.now()
except RegistryError as err: except RegistryError as err:
logger.error(f"Could not delete domain. Registry returned error: {err}") logger.error(f"Could not delete domain. Registry returned error: {err}")
raise err raise err
@ -1354,11 +1354,11 @@ class Domain(TimeStampedModel, DomainHelper):
""" """
logger.info("Changing to ready state") logger.info("Changing to ready state")
logger.info("able to transition to ready state") logger.info("able to transition to ready state")
# if self.first_ready_at is not None, this means that this # if self.first_ready is not None, this means that this
# domain was READY, then not READY, then is READY again. # domain was READY, then not READY, then is READY again.
# We do not want to overwrite first_ready_at. # We do not want to overwrite first_ready.
if self.first_ready_at is None: if self.first_ready is None:
self.first_ready_at = timezone.now() self.first_ready = timezone.now()
@transition( @transition(
field="state", field="state",

36
src/registrar/tests/test_models_domain.py
View file

@ -385,22 +385,22 @@ class TestDomainStatuses(MockEppLib):
"""Domain 'revert_client_hold' method causes the registry to change statuses""" """Domain 'revert_client_hold' method causes the registry to change statuses"""
raise raise
def test_first_ready_at(self): def test_first_ready(self):
""" """
first_ready_at is set when a domain is first transitioned to READY. It does not get overwritten first_ready is set when a domain is first transitioned to READY. It does not get overwritten
in case the domain gets out of and back into READY. in case the domain gets out of and back into READY.
""" """
domain, _ = Domain.objects.get_or_create(name="pig-knuckles.gov", state=Domain.State.DNS_NEEDED) domain, _ = Domain.objects.get_or_create(name="pig-knuckles.gov", state=Domain.State.DNS_NEEDED)
self.assertEqual(domain.first_ready_at, None) self.assertEqual(domain.first_ready, None)
domain.ready() domain.ready()
# check that status is READY # check that status is READY
self.assertTrue(domain.is_active()) self.assertTrue(domain.is_active())
self.assertNotEqual(domain.first_ready_at, None) self.assertNotEqual(domain.first_ready, None)
# Capture the value of first_ready_at # Capture the value of first_ready
first_ready_at = domain.first_ready_at first_ready = domain.first_ready
# change domain status # change domain status
domain.dns_needed() domain.dns_needed()
@ -410,8 +410,8 @@ class TestDomainStatuses(MockEppLib):
domain.ready() domain.ready()
self.assertTrue(domain.is_active()) self.assertTrue(domain.is_active())
# assert that the value of first_ready_at has not changed # assert that the value of first_ready has not changed
self.assertEqual(domain.first_ready_at, first_ready_at) self.assertEqual(domain.first_ready, first_ready)
def tearDown(self) -> None: def tearDown(self) -> None:
PublicContact.objects.all().delete() PublicContact.objects.all().delete()
@ -1139,7 +1139,7 @@ class TestRegistrantNameservers(MockEppLib):
Then `commands.CreateHost` and `commands.UpdateDomain` is sent Then `commands.CreateHost` and `commands.UpdateDomain` is sent
to the registry to the registry
And `domain.is_active` returns False And `domain.is_active` returns False
And domain.first_ready_at is null And domain.first_ready is null
""" """
# set 1 nameserver # set 1 nameserver
@ -1166,7 +1166,7 @@ class TestRegistrantNameservers(MockEppLib):
# as you have less than 2 nameservers # as you have less than 2 nameservers
self.assertFalse(self.domain.is_active()) self.assertFalse(self.domain.is_active())
self.assertEqual(self.domain.first_ready_at, None) self.assertEqual(self.domain.first_ready, None)
def test_user_adds_two_nameservers(self): def test_user_adds_two_nameservers(self):
""" """
@ -1176,7 +1176,7 @@ class TestRegistrantNameservers(MockEppLib):
Then `commands.CreateHost` and `commands.UpdateDomain` is sent Then `commands.CreateHost` and `commands.UpdateDomain` is sent
to the registry to the registry
And `domain.is_active` returns True And `domain.is_active` returns True
And domain.first_ready_at is not null And domain.first_ready is not null
""" """
# set 2 nameservers # set 2 nameservers
@ -1207,7 +1207,7 @@ class TestRegistrantNameservers(MockEppLib):
self.assertEqual(4, self.mockedSendFunction.call_count) self.assertEqual(4, self.mockedSendFunction.call_count)
# check that status is READY # check that status is READY
self.assertTrue(self.domain.is_active()) self.assertTrue(self.domain.is_active())
self.assertNotEqual(self.domain.first_ready_at, None) self.assertNotEqual(self.domain.first_ready, None)
def test_user_adds_too_many_nameservers(self): def test_user_adds_too_many_nameservers(self):
""" """
@ -2331,7 +2331,7 @@ class TestAnalystDelete(MockEppLib):
Then `commands.DeleteDomain` is sent to the registry Then `commands.DeleteDomain` is sent to the registry
And `state` is set to `DELETED` And `state` is set to `DELETED`
The deleted_at date is set. The deleted date is set.
""" """
# Put the domain in client hold # Put the domain in client hold
self.domain.place_client_hold() self.domain.place_client_hold()
@ -2353,8 +2353,8 @@ class TestAnalystDelete(MockEppLib):
# Domain should have the right state # Domain should have the right state
self.assertEqual(self.domain.state, Domain.State.DELETED) self.assertEqual(self.domain.state, Domain.State.DELETED)
# Domain should have a deleted_at # Domain should have a deleted
self.assertNotEqual(self.domain.deleted_at, None) self.assertNotEqual(self.domain.deleted, None)
# Cache should be invalidated # Cache should be invalidated
self.assertEqual(self.domain._cache, {}) self.assertEqual(self.domain._cache, {})
@ -2399,7 +2399,7 @@ class TestAnalystDelete(MockEppLib):
Then an FSM error is returned Then an FSM error is returned
And `state` is not set to `DELETED` And `state` is not set to `DELETED`
The deleted_at date is still null. The deleted date is still null.
""" """
self.assertEqual(self.domain.state, Domain.State.READY) self.assertEqual(self.domain.state, Domain.State.READY)
with self.assertRaises(TransitionNotAllowed) as err: with self.assertRaises(TransitionNotAllowed) as err:
@ -2411,5 +2411,5 @@ class TestAnalystDelete(MockEppLib):
# Domain should have the right state # Domain should have the right state
self.assertEqual(self.domain.state, Domain.State.READY) self.assertEqual(self.domain.state, Domain.State.READY)
# deleted_at should be null # deleted should be null
self.assertEqual(self.domain.deleted_at, None) self.assertEqual(self.domain.deleted, None)

32
src/registrar/tests/test_reports.py
View file

@ -232,23 +232,23 @@ class ExportDataTest(TestCase):
) )
self.domain_1, _ = Domain.objects.get_or_create( self.domain_1, _ = Domain.objects.get_or_create(
name="cdomain1.gov", state=Domain.State.READY, first_ready_at=timezone.now() name="cdomain1.gov", state=Domain.State.READY, first_ready=timezone.now()
) )
self.domain_2, _ = Domain.objects.get_or_create(name="adomain2.gov", state=Domain.State.DNS_NEEDED) self.domain_2, _ = Domain.objects.get_or_create(name="adomain2.gov", state=Domain.State.DNS_NEEDED)
self.domain_3, _ = Domain.objects.get_or_create(name="ddomain3.gov", state=Domain.State.ON_HOLD) self.domain_3, _ = Domain.objects.get_or_create(name="ddomain3.gov", state=Domain.State.ON_HOLD)
self.domain_4, _ = Domain.objects.get_or_create(name="bdomain4.gov", state=Domain.State.UNKNOWN) self.domain_4, _ = Domain.objects.get_or_create(name="bdomain4.gov", state=Domain.State.UNKNOWN)
self.domain_4, _ = Domain.objects.get_or_create(name="bdomain4.gov", state=Domain.State.UNKNOWN) self.domain_4, _ = Domain.objects.get_or_create(name="bdomain4.gov", state=Domain.State.UNKNOWN)
self.domain_5, _ = Domain.objects.get_or_create( self.domain_5, _ = Domain.objects.get_or_create(
name="bdomain5.gov", state=Domain.State.DELETED, deleted_at=timezone.make_aware(datetime(2023, 11, 1)) name="bdomain5.gov", state=Domain.State.DELETED, deleted=timezone.make_aware(datetime(2023, 11, 1))
) )
self.domain_6, _ = Domain.objects.get_or_create( self.domain_6, _ = Domain.objects.get_or_create(
name="bdomain6.gov", state=Domain.State.DELETED, deleted_at=timezone.make_aware(datetime(1980, 10, 16)) name="bdomain6.gov", state=Domain.State.DELETED, deleted=timezone.make_aware(datetime(1980, 10, 16))
) )
self.domain_7, _ = Domain.objects.get_or_create( self.domain_7, _ = Domain.objects.get_or_create(
name="xdomain7.gov", state=Domain.State.DELETED, deleted_at=timezone.now() name="xdomain7.gov", state=Domain.State.DELETED, deleted=timezone.now()
) )
self.domain_8, _ = Domain.objects.get_or_create( self.domain_8, _ = Domain.objects.get_or_create(
name="sdomain8.gov", state=Domain.State.DELETED, deleted_at=timezone.now() name="sdomain8.gov", state=Domain.State.DELETED, deleted=timezone.now()
) )
# We use timezone.make_aware to sync to server time a datetime object with the current date (using date.today()) # We use timezone.make_aware to sync to server time a datetime object with the current date (using date.today())
# and a specific time (using datetime.min.time()). # and a specific time (using datetime.min.time()).
@ -256,13 +256,13 @@ class ExportDataTest(TestCase):
self.domain_9, _ = Domain.objects.get_or_create( self.domain_9, _ = Domain.objects.get_or_create(
name="zdomain9.gov", name="zdomain9.gov",
state=Domain.State.DELETED, state=Domain.State.DELETED,
deleted_at=timezone.make_aware(datetime.combine(date.today() - timedelta(days=1), datetime.min.time())), deleted=timezone.make_aware(datetime.combine(date.today() - timedelta(days=1), datetime.min.time())),
) )
# ready tomorrow # ready tomorrow
self.domain_10, _ = Domain.objects.get_or_create( self.domain_10, _ = Domain.objects.get_or_create(
name="adomain10.gov", name="adomain10.gov",
state=Domain.State.READY, state=Domain.State.READY,
first_ready_at=timezone.make_aware(datetime.combine(date.today() + timedelta(days=1), datetime.min.time())), first_ready=timezone.make_aware(datetime.combine(date.today() + timedelta(days=1), datetime.min.time())),
) )
self.domain_information_1, _ = DomainInformation.objects.get_or_create( self.domain_information_1, _ = DomainInformation.objects.get_or_create(
@ -451,10 +451,10 @@ class ExportDataTest(TestCase):
def test_write_body_with_date_filter_pulls_domains_in_range(self): def test_write_body_with_date_filter_pulls_domains_in_range(self):
"""Test that domains that are """Test that domains that are
1. READY and their first_ready_at dates are in range 1. READY and their first_ready dates are in range
2. DELETED and their deleted_at dates are in range 2. DELETED and their deleted dates are in range
are pulled when the growth report conditions are applied to export_domains_to_writed. are pulled when the growth report conditions are applied to export_domains_to_writed.
Test that ready domains are sorted by first_ready_at/deleted_at dates first, names second. Test that ready domains are sorted by first_ready/deleted dates first, names second.
We considered testing export_data_growth_to_csv which calls write_body We considered testing export_data_growth_to_csv which calls write_body
and would have been easy to set up, but expected_content would contain created_at dates and would have been easy to set up, but expected_content would contain created_at dates
@ -486,22 +486,22 @@ class ExportDataTest(TestCase):
"domain__name", "domain__name",
] ]
sort_fields_for_deleted_domains = [ sort_fields_for_deleted_domains = [
"domain__deleted_at", "domain__deleted",
"domain__name", "domain__name",
] ]
filter_condition = { filter_condition = {
"domain__state__in": [ "domain__state__in": [
Domain.State.READY, Domain.State.READY,
], ],
"domain__first_ready_at__lte": end_date, "domain__first_ready__lte": end_date,
"domain__first_ready_at__gte": start_date, "domain__first_ready__gte": start_date,
} }
filter_conditions_for_deleted_domains = { filter_conditions_for_deleted_domains = {
"domain__state__in": [ "domain__state__in": [
Domain.State.DELETED, Domain.State.DELETED,
], ],
"domain__deleted_at__lte": end_date, "domain__deleted__lte": end_date,
"domain__deleted_at__gte": start_date, "domain__deleted__gte": start_date,
} }
# Call the export functions # Call the export functions
@ -526,7 +526,7 @@ class ExportDataTest(TestCase):
csv_content = csv_file.read() csv_content = csv_file.read()
# We expect READY domains first, created between today-2 and today+2, sorted by created_at then name # We expect READY domains first, created between today-2 and today+2, sorted by created_at then name
# and DELETED domains deleted between today-2 and today+2, sorted by deleted_at then name # and DELETED domains deleted between today-2 and today+2, sorted by deleted then name
expected_content = ( expected_content = (
"Domain name,Domain type,Agency,Organization name,City," "Domain name,Domain type,Agency,Organization name,City,"
"State,Status,Expiration date\n" "State,Status,Expiration date\n"

22
src/registrar/utility/csv_export.py
View file

@ -48,8 +48,8 @@ def write_row(writer, columns, domain_info):
"Status": domain_info.domain.get_state_display(), "Status": domain_info.domain.get_state_display(),
"Expiration date": domain_info.domain.expiration_date, "Expiration date": domain_info.domain.expiration_date,
"Created at": domain_info.domain.created_at, "Created at": domain_info.domain.created_at,
"First ready at": domain_info.domain.first_ready_at, "First ready": domain_info.domain.first_ready,
"Deleted at": domain_info.domain.deleted_at, "Deleted": domain_info.domain.deleted,
} }
writer.writerow([FIELDS.get(column, "") for column in columns]) writer.writerow([FIELDS.get(column, "") for column in columns])
@ -214,30 +214,30 @@ def export_data_growth_to_csv(csv_file, start_date, end_date):
"City", "City",
"State", "State",
"Status", "Status",
"Created at",
"First ready at",
"Deleted at",
"Expiration date", "Expiration date",
"Created at",
"First ready",
"Deleted",
] ]
sort_fields = [ sort_fields = [
"domain__first_ready_at", "domain__first_ready",
"domain__name", "domain__name",
] ]
filter_condition = { filter_condition = {
"domain__state__in": [Domain.State.READY], "domain__state__in": [Domain.State.READY],
"domain__first_ready_at__lte": end_date_formatted, "domain__first_ready__lte": end_date_formatted,
"domain__first_ready_at__gte": start_date_formatted, "domain__first_ready__gte": start_date_formatted,
} }
# We also want domains deleted between sar and end dates, sorted # We also want domains deleted between sar and end dates, sorted
sort_fields_for_deleted_domains = [ sort_fields_for_deleted_domains = [
"domain__deleted_at", "domain__deleted",
"domain__name", "domain__name",
] ]
filter_condition_for_deleted_domains = { filter_condition_for_deleted_domains = {
"domain__state__in": [Domain.State.DELETED], "domain__state__in": [Domain.State.DELETED],
"domain__deleted_at__lte": end_date_formatted, "domain__deleted__lte": end_date_formatted,
"domain__deleted_at__gte": start_date_formatted, "domain__deleted__gte": start_date_formatted,
} }
write_header(writer, columns) write_header(writer, columns)