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

code formatting for readability

Browse source
This commit is contained in:
David Kennedy 2024-05-22 17:37:34 -04:00
parent f5408c4206
commit 1fd23ba786
No known key found for this signature in database
GPG key ID: 6528A5386E66B96B
10 changed files with 127 additions and 137 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/registrar/config/urls.py
View file

@ -195,8 +195,8 @@ urlpatterns = [
views.DomainDeleteUserView.as_view(http_method_names=["post"]),
name="domain-user-delete",
),
path('get-domains-json/', get_domains_json, name='get_domains_json'),
path('get-domain-requests-json/', get_domain_requests_json, name='get_domain_requests_json'),
path("get-domains-json/", get_domains_json, name="get_domains_json"),
path("get-domain-requests-json/", get_domain_requests_json, name="get_domain_requests_json"),
]
# Djangooidc strips out context data from that context, so we define a custom error

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

@ -1024,7 +1024,6 @@ class Domain(TimeStampedModel, DomainHelper):
verbose_name="domain state",
)
expiration_date = DateField(
null=True,
help_text=("Date the domain expires in the registry"),
@ -1066,9 +1065,9 @@ class Domain(TimeStampedModel, DomainHelper):
def state_display(self):
"""Return the display status of the domain."""
if self.is_expired() and self.state != self.State.UNKNOWN:
return 'Expired'
return "Expired"
elif self.state == self.State.UNKNOWN or self.state == self.State.DNS_NEEDED:
return 'DNS needed'
return "DNS needed"
else:
return self.state.capitalize()

4
src/registrar/tests/test_views.py
View file

@ -164,9 +164,7 @@ class HomeTests(TestWithUser):
deleted_text = "This domain has been removed and " "is no longer registered to your organization."
dns_needed_text = "Before this domain can be used, "
ready_text = "This domain has name servers and is ready for use."
on_hold_text = (
"This domain is administratively paused, "
)
on_hold_text = "This domain is administratively paused, "
deleted_text = "This domain has been removed and " "is no longer registered to your organization."
# Generate a mapping of domain names, the state, and expected messages for the subtest
test_cases = [

2
src/registrar/tests/test_views_domain.py
View file

@ -239,7 +239,7 @@ class TestDomainDetail(TestDomainOverview):
igorville = Domain.objects.get(name="igorville.gov")
self.assertEquals(igorville.state, Domain.State.UNKNOWN)
detail_page = self.app.get(f'/domain/{igorville.id}')
detail_page = self.app.get(f"/domain/{igorville.id}")
self.assertContains(detail_page, "Expired")
self.assertNotContains(detail_page, "DNS needed")

61
src/registrar/tests/test_views_domains_json.py
View file

@ -3,27 +3,16 @@ from django.urls import reverse
from .test_views import TestWithUser
from django_webtest import WebTest # type: ignore
class GetDomainsJsonTest(TestWithUser, WebTest):
def setUp(self):
super().setUp()
self.app.set_user(self.user.username)
# Create test domains
self.domain1 = Domain.objects.create(
name='example1.com',
expiration_date='2024-01-01',
state='active'
)
self.domain2 = Domain.objects.create(
name='example2.com',
expiration_date='2024-02-01',
state='inactive'
)
self.domain3 = Domain.objects.create(
name='example3.com',
expiration_date='2024-03-01',
state='active'
)
self.domain1 = Domain.objects.create(name="example1.com", expiration_date="2024-01-01", state="active")
self.domain2 = Domain.objects.create(name="example2.com", expiration_date="2024-02-01", state="inactive")
self.domain3 = Domain.objects.create(name="example3.com", expiration_date="2024-03-01", state="active")
# Create UserDomainRoles
UserDomainRole.objects.create(user=self.user, domain=self.domain1)
@ -34,68 +23,68 @@ class GetDomainsJsonTest(TestWithUser, WebTest):
# Logout the user
self.app.reset()
response = self.client.get(reverse('get_domains_json'))
response = self.client.get(reverse("get_domains_json"))
self.assertEqual(response.status_code, 302)
def test_get_domains_json_authenticated(self):
response = self.app.get(reverse('get_domains_json'))
response = self.app.get(reverse("get_domains_json"))
self.assertEqual(response.status_code, 200)
data = response.json
# Check pagination info
self.assertEqual(data['page'], 1)
self.assertFalse(data['has_next'])
self.assertFalse(data['has_previous'])
self.assertEqual(data['num_pages'], 1)
self.assertEqual(data["page"], 1)
self.assertFalse(data["has_next"])
self.assertFalse(data["has_previous"])
self.assertEqual(data["num_pages"], 1)
# Check domains
self.assertEqual(len(data['domains']), 3)
domain_ids = [domain['id'] for domain in data['domains']]
self.assertEqual(len(data["domains"]), 3)
domain_ids = [domain["id"] for domain in data["domains"]]
self.assertIn(self.domain1.id, domain_ids)
self.assertIn(self.domain2.id, domain_ids)
self.assertIn(self.domain3.id, domain_ids)
def test_pagination(self):
response = self.app.get(reverse('get_domains_json'), {'page': 1})
response = self.app.get(reverse("get_domains_json"), {"page": 1})
self.assertEqual(response.status_code, 200)
data = response.json
# Check pagination info
self.assertEqual(data['page'], 1)
self.assertFalse(data['has_next'])
self.assertFalse(data['has_previous'])
self.assertEqual(data['num_pages'], 1)
self.assertEqual(data["page"], 1)
self.assertFalse(data["has_next"])
self.assertFalse(data["has_previous"])
self.assertEqual(data["num_pages"], 1)
def test_sorting(self):
response = self.app.get(reverse('get_domains_json'), {'sort_by': 'expiration_date', 'order': 'desc'})
response = self.app.get(reverse("get_domains_json"), {"sort_by": "expiration_date", "order": "desc"})
self.assertEqual(response.status_code, 200)
data = response.json
# Check if sorted by expiration_date in descending order
expiration_dates = [domain['expiration_date'] for domain in data['domains']]
expiration_dates = [domain["expiration_date"] for domain in data["domains"]]
self.assertEqual(expiration_dates, sorted(expiration_dates, reverse=True))
response = self.app.get(reverse('get_domains_json'), {'sort_by': 'expiration_date', 'order': 'asc'})
response = self.app.get(reverse("get_domains_json"), {"sort_by": "expiration_date", "order": "asc"})
self.assertEqual(response.status_code, 200)
data = response.json
# Check if sorted by expiration_date in ascending order
expiration_dates = [domain['expiration_date'] for domain in data['domains']]
expiration_dates = [domain["expiration_date"] for domain in data["domains"]]
self.assertEqual(expiration_dates, sorted(expiration_dates))
def test_sorting_by_state_display(self):
response = self.app.get(reverse('get_domains_json'), {'sort_by': 'state_display', 'order': 'asc'})
response = self.app.get(reverse("get_domains_json"), {"sort_by": "state_display", "order": "asc"})
self.assertEqual(response.status_code, 200)
data = response.json
# Check if sorted by state_display in ascending order
states = [domain['state_display'] for domain in data['domains']]
states = [domain["state_display"] for domain in data["domains"]]
self.assertEqual(states, sorted(states))
response = self.app.get(reverse('get_domains_json'), {'sort_by': 'state_display', 'order': 'desc'})
response = self.app.get(reverse("get_domains_json"), {"sort_by": "state_display", "order": "desc"})
self.assertEqual(response.status_code, 200)
data = response.json
# Check if sorted by state_display in descending order
states = [domain['state_display'] for domain in data['domains']]
states = [domain["state_display"] for domain in data["domains"]]
self.assertEqual(states, sorted(states, reverse=True))

18
src/registrar/tests/test_views_request.py
View file

@ -48,7 +48,7 @@ class DomainRequestTests(TestWithUser, WebTest):
def test_domain_request_form_intro_is_skipped_when_edit_access(self):
"""Tests that user is NOT presented with intro acknowledgement page when accessed through 'edit'"""
domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.STARTED, user=self.user)
detail_page = self.app.get(f'/domain-request/{domain_request.id}/edit/')
detail_page = self.app.get(f"/domain-request/{domain_request.id}/edit/")
# Check that the response is a redirect
self.assertEqual(detail_page.status_code, 302)
# You can access the 'Location' header to get the redirect URL
@ -2399,7 +2399,7 @@ class DomainRequestTestDifferentStatuses(TestWithUser, WebTest):
domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.SUBMITTED, user=self.user)
domain_request.save()
detail_page = self.app.get(f'/domain-request/{domain_request.id}')
detail_page = self.app.get(f"/domain-request/{domain_request.id}")
self.assertContains(detail_page, "city.gov")
self.assertContains(detail_page, "city1.gov")
self.assertContains(detail_page, "Chief Tester")
@ -2416,7 +2416,7 @@ class DomainRequestTestDifferentStatuses(TestWithUser, WebTest):
domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.SUBMITTED, user=self.user)
domain_request.save()
detail_page = self.app.get(f'/domain-request/{domain_request.id}')
detail_page = self.app.get(f"/domain-request/{domain_request.id}")
self.assertContains(detail_page, "city.gov")
self.assertContains(detail_page, "Chief Tester")
self.assertContains(detail_page, "testy@town.com")
@ -2428,7 +2428,7 @@ class DomainRequestTestDifferentStatuses(TestWithUser, WebTest):
domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.SUBMITTED, user=self.user)
domain_request.save()
detail_page = self.app.get(f'/domain-request/{domain_request.id}')
detail_page = self.app.get(f"/domain-request/{domain_request.id}")
self.assertContains(detail_page, "city.gov")
self.assertContains(detail_page, "city1.gov")
self.assertContains(detail_page, "Chief Tester")
@ -2450,7 +2450,7 @@ class DomainRequestTestDifferentStatuses(TestWithUser, WebTest):
target_status_code=200,
fetch_redirect_response=True,
)
response = self.client.get('/get-domain-requests-json/')
response = self.client.get("/get-domain-requests-json/")
self.assertContains(response, "Withdrawn")
def test_domain_request_withdraw_no_permissions(self):
@ -2460,7 +2460,7 @@ class DomainRequestTestDifferentStatuses(TestWithUser, WebTest):
domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.SUBMITTED, user=self.user)
domain_request.save()
detail_page = self.app.get(f'/domain-request/{domain_request.id}')
detail_page = self.app.get(f"/domain-request/{domain_request.id}")
self.assertContains(detail_page, "city.gov")
self.assertContains(detail_page, "city1.gov")
self.assertContains(detail_page, "Chief Tester")
@ -2532,8 +2532,8 @@ class TestWizardUnlockingSteps(TestWithUser, WebTest):
domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.STARTED, user=self.user)
response = self.app.get(f'/domain-request/{domain_request.id}/edit/')
# django-webtest does not handle cookie-based sessions well because it keeps
response = self.app.get(f"/domain-request/{domain_request.id}/edit/")
# django-webtest does not handle cookie-based sessions well because it keeps
# resetting the session key on each new request, thus destroying the concept
# of a "session". We are going to do it manually, saving the session ID here
# and then setting the cookie on each request.
@ -2590,7 +2590,7 @@ class TestWizardUnlockingSteps(TestWithUser, WebTest):
)
domain_request.other_contacts.set([contact_2])
response = self.app.get(f'/domain-request/{domain_request.id}/edit/')
response = self.app.get(f"/domain-request/{domain_request.id}/edit/")
# django-webtest does not handle cookie-based sessions well because it keeps
# resetting the session key on each new request, thus destroying the concept
# of a "session". We are going to do it manually, saving the session ID here

79
src/registrar/tests/test_views_requests_json.py
View file

@ -1,10 +1,9 @@
from django.test import Client
from django.contrib.auth.models import User
from registrar.models import DomainRequest
from django.urls import reverse
from .test_views import TestWithUser
from django_webtest import WebTest # type: ignore
class DomainRequestViewTest(TestWithUser, WebTest):
def setUp(self):
super().setUp()
@ -17,146 +16,146 @@ class DomainRequestViewTest(TestWithUser, WebTest):
requested_domain=None, # Assuming requested_domain is an optional field
submission_date="2024-01-01",
status=DomainRequest.DomainRequestStatus.STARTED,
created_at="2024-01-01"
created_at="2024-01-01",
),
DomainRequest.objects.create(
creator=self.user,
requested_domain=None,
submission_date="2024-02-01",
status=DomainRequest.DomainRequestStatus.WITHDRAWN,
created_at="2024-02-01"
created_at="2024-02-01",
),
DomainRequest.objects.create(
creator=self.user,
requested_domain=None,
submission_date="2024-03-01",
status=DomainRequest.DomainRequestStatus.REJECTED,
created_at="2024-03-01"
created_at="2024-03-01",
),
DomainRequest.objects.create(
creator=self.user,
requested_domain=None,
submission_date="2024-04-01",
status=DomainRequest.DomainRequestStatus.STARTED,
created_at="2024-04-01"
created_at="2024-04-01",
),
DomainRequest.objects.create(
creator=self.user,
requested_domain=None, # Assuming requested_domain is an optional field
submission_date="2024-05-01",
status=DomainRequest.DomainRequestStatus.STARTED,
created_at="2024-05-01"
created_at="2024-05-01",
),
DomainRequest.objects.create(
creator=self.user,
requested_domain=None,
submission_date="2024-06-01",
status=DomainRequest.DomainRequestStatus.WITHDRAWN,
created_at="2024-06-01"
created_at="2024-06-01",
),
DomainRequest.objects.create(
creator=self.user,
requested_domain=None,
submission_date="2024-07-01",
status=DomainRequest.DomainRequestStatus.REJECTED,
created_at="2024-07-01"
created_at="2024-07-01",
),
DomainRequest.objects.create(
creator=self.user,
requested_domain=None,
submission_date="2024-08-01",
status=DomainRequest.DomainRequestStatus.STARTED,
created_at="2024-08-01"
created_at="2024-08-01",
),
DomainRequest.objects.create(
creator=self.user,
requested_domain=None, # Assuming requested_domain is an optional field
submission_date="2024-09-01",
status=DomainRequest.DomainRequestStatus.STARTED,
created_at="2024-09-01"
created_at="2024-09-01",
),
DomainRequest.objects.create(
creator=self.user,
requested_domain=None,
submission_date="2024-10-01",
status=DomainRequest.DomainRequestStatus.WITHDRAWN,
created_at="2024-10-01"
created_at="2024-10-01",
),
DomainRequest.objects.create(
creator=self.user,
requested_domain=None,
submission_date="2024-11-01",
status=DomainRequest.DomainRequestStatus.REJECTED,
created_at="2024-11-01"
created_at="2024-11-01",
),
DomainRequest.objects.create(
creator=self.user,
requested_domain=None,
submission_date="2024-12-01",
status=DomainRequest.DomainRequestStatus.APPROVED,
created_at="2024-12-01"
)
created_at="2024-12-01",
),
]
def test_get_domain_requests_json_authenticated(self):
response = self.app.get(reverse('get_domain_requests_json'))
response = self.app.get(reverse("get_domain_requests_json"))
self.assertEqual(response.status_code, 200)
data = response.json
# Check pagination info
self.assertEqual(data['page'], 1)
self.assertTrue(data['has_next'])
self.assertFalse(data['has_previous'])
self.assertEqual(data['num_pages'], 2)
self.assertEqual(data["page"], 1)
self.assertTrue(data["has_next"])
self.assertFalse(data["has_previous"])
self.assertEqual(data["num_pages"], 2)
# Check domain requests
self.assertEqual(len(data['domain_requests']), 10)
for domain_request in data['domain_requests']:
self.assertNotEqual(domain_request['status'], 'Approved')
self.assertEqual(len(data["domain_requests"]), 10)
for domain_request in data["domain_requests"]:
self.assertNotEqual(domain_request["status"], "Approved")
def test_pagination(self):
response = self.app.get(reverse('get_domain_requests_json'), {'page': 1})
response = self.app.get(reverse("get_domain_requests_json"), {"page": 1})
self.assertEqual(response.status_code, 200)
data = response.json
# Check pagination info
self.assertEqual(data['page'], 1)
self.assertTrue(data['has_next'])
self.assertFalse(data['has_previous'])
self.assertEqual(data['num_pages'], 2)
self.assertEqual(data["page"], 1)
self.assertTrue(data["has_next"])
self.assertFalse(data["has_previous"])
self.assertEqual(data["num_pages"], 2)
response = self.app.get(reverse('get_domain_requests_json'), {'page': 2})
response = self.app.get(reverse("get_domain_requests_json"), {"page": 2})
self.assertEqual(response.status_code, 200)
data = response.json
# Check pagination info
self.assertEqual(data['page'], 2)
self.assertFalse(data['has_next'])
self.assertTrue(data['has_previous'])
self.assertEqual(data['num_pages'], 2)
self.assertEqual(data["page"], 2)
self.assertFalse(data["has_next"])
self.assertTrue(data["has_previous"])
self.assertEqual(data["num_pages"], 2)
def test_sorting(self):
response = self.app.get(reverse('get_domain_requests_json'), {'sort_by': 'submission_date', 'order': 'desc'})
response = self.app.get(reverse("get_domain_requests_json"), {"sort_by": "submission_date", "order": "desc"})
self.assertEqual(response.status_code, 200)
data = response.json
# Check if sorted by submission_date in descending order
submission_dates = [req['submission_date'] for req in data['domain_requests']]
submission_dates = [req["submission_date"] for req in data["domain_requests"]]
self.assertEqual(submission_dates, sorted(submission_dates, reverse=True))
response = self.app.get(reverse('get_domain_requests_json'), {'sort_by': 'submission_date', 'order': 'asc'})
response = self.app.get(reverse("get_domain_requests_json"), {"sort_by": "submission_date", "order": "asc"})
self.assertEqual(response.status_code, 200)
data = response.json
# Check if sorted by submission_date in ascending order
submission_dates = [req['submission_date'] for req in data['domain_requests']]
submission_dates = [req["submission_date"] for req in data["domain_requests"]]
self.assertEqual(submission_dates, sorted(submission_dates))
def test_filter_approved_excluded(self):
response = self.app.get(reverse('get_domain_requests_json'))
response = self.app.get(reverse("get_domain_requests_json"))
self.assertEqual(response.status_code, 200)
data = response.json
# Ensure no approved requests are included
for domain_request in data['domain_requests']:
self.assertNotEqual(domain_request['status'], DomainRequest.DomainRequestStatus.APPROVED)
for domain_request in data["domain_requests"]:
self.assertNotEqual(domain_request["status"], DomainRequest.DomainRequestStatus.APPROVED)

44
src/registrar/views/domain_requests_json.py
View file

@ -2,42 +2,46 @@ from django.http import JsonResponse
from django.core.paginator import Paginator
from registrar.models import DomainRequest
def get_domain_requests_json(request):
"""Given the current request,
get all domain requests that are associated with the request user and exclude the APPROVED ones"""
if not request.user.is_authenticated:
return JsonResponse({'error': 'User not authenticated'}, status=401)
return JsonResponse({"error": "User not authenticated"}, status=401)
domain_requests = DomainRequest.objects.filter(creator=request.user).exclude(
status=DomainRequest.DomainRequestStatus.APPROVED
)
# Handle sorting
sort_by = request.GET.get('sort_by', 'id') # Default to 'id'
order = request.GET.get('order', 'asc') # Default to 'asc'
if order == 'desc':
sort_by = f'-{sort_by}'
sort_by = request.GET.get("sort_by", "id") # Default to 'id'
order = request.GET.get("order", "asc") # Default to 'asc'
if order == "desc":
sort_by = f"-{sort_by}"
domain_requests = domain_requests.order_by(sort_by)
page_number = request.GET.get('page', 1)
page_number = request.GET.get("page", 1)
paginator = Paginator(domain_requests, 10) # Adjust the number of items per page as needed
page_obj = paginator.get_page(page_number)
domain_requests_data = [
{
'requested_domain': domain_request.requested_domain.name if domain_request.requested_domain else None,
'submission_date': domain_request.submission_date,
'status': domain_request.get_status_display(),
'created_at': domain_request.created_at,
'id': domain_request.id,
'is_deletable': domain_request.status in [DomainRequest.DomainRequestStatus.STARTED, DomainRequest.DomainRequestStatus.WITHDRAWN],
"requested_domain": domain_request.requested_domain.name if domain_request.requested_domain else None,
"submission_date": domain_request.submission_date,
"status": domain_request.get_status_display(),
"created_at": domain_request.created_at,
"id": domain_request.id,
"is_deletable": domain_request.status
in [DomainRequest.DomainRequestStatus.STARTED, DomainRequest.DomainRequestStatus.WITHDRAWN],
}
for domain_request in page_obj
]
return JsonResponse({
'domain_requests': domain_requests_data,
'has_next': page_obj.has_next(),
'has_previous': page_obj.has_previous(),
'page': page_obj.number,
'num_pages': paginator.num_pages,
})
return JsonResponse(
{
"domain_requests": domain_requests_data,
"has_next": page_obj.has_next(),
"has_previous": page_obj.has_previous(),
"page": page_obj.number,
"num_pages": paginator.num_pages,
}
)

45
src/registrar/views/domains_json.py
View file

@ -2,12 +2,13 @@ from django.http import JsonResponse
from django.core.paginator import Paginator
from registrar.models import UserDomainRole, Domain
def get_domains_json(request):
"""Given the current request,
get all domains that are associated with the UserDomainRole object"""
if not request.user.is_authenticated:
return JsonResponse({'error': 'User not authenticated'}, status=401)
return JsonResponse({"error": "User not authenticated"}, status=401)
user_domain_roles = UserDomainRole.objects.filter(user=request.user)
domain_ids = user_domain_roles.values_list("domain_id", flat=True)
@ -15,40 +16,42 @@ def get_domains_json(request):
objects = Domain.objects.filter(id__in=domain_ids)
# Handle sorting
sort_by = request.GET.get('sort_by', 'id') # Default to 'id'
order = request.GET.get('order', 'asc') # Default to 'asc'
sort_by = request.GET.get("sort_by", "id") # Default to 'id'
order = request.GET.get("order", "asc") # Default to 'asc'
if sort_by == 'state_display':
if sort_by == "state_display":
# Fetch the objects and sort them in Python
objects = list(objects) # Evaluate queryset to a list
objects.sort(key=lambda domain: domain.state_display(), reverse=(order == 'desc'))
objects.sort(key=lambda domain: domain.state_display(), reverse=(order == "desc"))
else:
if order == 'desc':
sort_by = f'-{sort_by}'
if order == "desc":
sort_by = f"-{sort_by}"
objects = objects.order_by(sort_by)
paginator = Paginator(objects, 10)
page_number = request.GET.get('page')
page_number = request.GET.get("page")
page_obj = paginator.get_page(page_number)
# Convert objects to JSON-serializable format
domains = [
{
'id': domain.id,
'name': domain.name,
'expiration_date': domain.expiration_date,
'state': domain.state,
'state_display': domain.state_display(),
'get_state_help_text': domain.get_state_help_text(),
"id": domain.id,
"name": domain.name,
"expiration_date": domain.expiration_date,
"state": domain.state,
"state_display": domain.state_display(),
"get_state_help_text": domain.get_state_help_text(),
# Add other fields as necessary
}
for domain in page_obj.object_list
]
return JsonResponse({
'domains': domains,
'page': page_obj.number,
'num_pages': paginator.num_pages,
'has_previous': page_obj.has_previous(),
'has_next': page_obj.has_next(),
})
return JsonResponse(
{
"domains": domains,
"page": page_obj.number,
"num_pages": paginator.num_pages,
"has_previous": page_obj.has_previous(),
"has_next": page_obj.has_next(),
}
)

2
src/registrar/views/index.py
View file

@ -13,7 +13,6 @@ def index(request):
context["domain_requests"] = domain_requests
# Determine if the user will see domain requests that they can delete
has_deletable_domain_requests = deletable_domain_requests.exists()
context["has_deletable_domain_requests"] = has_deletable_domain_requests
@ -52,4 +51,3 @@ def _get_domain_requests(request):
deletable_domain_requests = domain_requests.filter(status__in=valid_statuses)
return (domain_requests, deletable_domain_requests)