mirror of
https://github.com/cisagov/manage.get.gov.git
synced 2025-08-03 16:32:15 +02:00
205 lines
8.5 KiB
Python
205 lines
8.5 KiB
Python
from registrar.models import UserDomainRole, Domain
|
|
from django.urls import reverse
|
|
from .test_views import TestWithUser
|
|
from django_webtest import WebTest # type: ignore
|
|
from django.utils.dateparse import parse_date
|
|
from api.tests.common import less_console_noise_decorator
|
|
|
|
|
|
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="unknown")
|
|
self.domain2 = Domain.objects.create(name="example2.com", expiration_date="2024-02-01", state="dns needed")
|
|
self.domain3 = Domain.objects.create(name="example3.com", expiration_date="2024-03-01", state="ready")
|
|
|
|
# Create UserDomainRoles
|
|
UserDomainRole.objects.create(user=self.user, domain=self.domain1)
|
|
UserDomainRole.objects.create(user=self.user, domain=self.domain2)
|
|
UserDomainRole.objects.create(user=self.user, domain=self.domain3)
|
|
|
|
def tearDown(self):
|
|
super().tearDown()
|
|
UserDomainRole.objects.all().delete()
|
|
UserDomainRole.objects.all().delete()
|
|
|
|
@less_console_noise_decorator
|
|
def test_get_domains_json_unauthenticated(self):
|
|
"""for an unauthenticated user, test that the user is redirected for auth"""
|
|
self.app.reset()
|
|
|
|
response = self.client.get(reverse("get_domains_json"))
|
|
self.assertEqual(response.status_code, 302)
|
|
|
|
@less_console_noise_decorator
|
|
def test_get_domains_json_authenticated(self):
|
|
"""Test that an authenticated user gets the list of 3 domains."""
|
|
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)
|
|
|
|
# Check the number of domains
|
|
self.assertEqual(len(data["domains"]), 3)
|
|
|
|
# Expected domains
|
|
expected_domains = [self.domain1, self.domain2, self.domain3]
|
|
|
|
# Extract fields from response
|
|
domain_ids = [domain["id"] for domain in data["domains"]]
|
|
names = [domain["name"] for domain in data["domains"]]
|
|
expiration_dates = [domain["expiration_date"] for domain in data["domains"]]
|
|
states = [domain["state"] for domain in data["domains"]]
|
|
state_displays = [domain["state_display"] for domain in data["domains"]]
|
|
get_state_help_texts = [domain["get_state_help_text"] for domain in data["domains"]]
|
|
action_urls = [domain["action_url"] for domain in data["domains"]]
|
|
action_labels = [domain["action_label"] for domain in data["domains"]]
|
|
svg_icons = [domain["svg_icon"] for domain in data["domains"]]
|
|
|
|
# Check fields for each domain
|
|
for i, expected_domain in enumerate(expected_domains):
|
|
self.assertEqual(expected_domain.id, domain_ids[i])
|
|
self.assertEqual(expected_domain.name, names[i])
|
|
self.assertEqual(expected_domain.expiration_date, expiration_dates[i])
|
|
self.assertEqual(expected_domain.state, states[i])
|
|
|
|
# Parsing the expiration date from string to date
|
|
parsed_expiration_date = parse_date(expiration_dates[i])
|
|
expected_domain.expiration_date = parsed_expiration_date
|
|
|
|
# Check state_display and get_state_help_text
|
|
self.assertEqual(expected_domain.state_display(), state_displays[i])
|
|
self.assertEqual(expected_domain.get_state_help_text(), get_state_help_texts[i])
|
|
|
|
self.assertEqual(reverse("domain", kwargs={"pk": expected_domain.id}), action_urls[i])
|
|
|
|
# Check action_label
|
|
action_label_expected = (
|
|
"View"
|
|
if expected_domains[i].state
|
|
in [
|
|
Domain.State.DELETED,
|
|
Domain.State.ON_HOLD,
|
|
]
|
|
else "Manage"
|
|
)
|
|
self.assertEqual(action_label_expected, action_labels[i])
|
|
|
|
# Check svg_icon
|
|
svg_icon_expected = (
|
|
"visibility"
|
|
if expected_domains[i].state
|
|
in [
|
|
Domain.State.DELETED,
|
|
Domain.State.ON_HOLD,
|
|
]
|
|
else "settings"
|
|
)
|
|
self.assertEqual(svg_icon_expected, svg_icons[i])
|
|
|
|
@less_console_noise_decorator
|
|
def test_get_domains_json_search(self):
|
|
"""Test search."""
|
|
# Define your URL variables as a dictionary
|
|
url_vars = {"search_term": "e2"}
|
|
|
|
# Use the params parameter to include URL variables
|
|
response = self.app.get(reverse("get_domains_json"), params=url_vars)
|
|
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["total"], 1)
|
|
self.assertEqual(data["unfiltered_total"], 3)
|
|
|
|
# Check the number of domain requests
|
|
self.assertEqual(len(data["domains"]), 1)
|
|
|
|
# Extract fields from response
|
|
domains = [request["name"] for request in data["domains"]]
|
|
|
|
self.assertEqual(
|
|
self.domain2.name,
|
|
domains[0],
|
|
)
|
|
|
|
@less_console_noise_decorator
|
|
def test_pagination(self):
|
|
"""Test that pagination is correct in the response"""
|
|
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)
|
|
|
|
@less_console_noise_decorator
|
|
def test_sorting(self):
|
|
"""test that sorting works properly in the response"""
|
|
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"]]
|
|
self.assertEqual(expiration_dates, sorted(expiration_dates, reverse=True))
|
|
|
|
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"]]
|
|
self.assertEqual(expiration_dates, sorted(expiration_dates))
|
|
|
|
@less_console_noise_decorator
|
|
def test_sorting_by_state_display(self):
|
|
"""test that the state_display sorting works properly"""
|
|
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"]]
|
|
self.assertEqual(states, sorted(states))
|
|
|
|
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"]]
|
|
self.assertEqual(states, sorted(states, reverse=True))
|
|
|
|
@less_console_noise_decorator
|
|
def test_state_filtering(self):
|
|
"""Test that different states in request get expected responses."""
|
|
|
|
expected_values = [
|
|
("unknown", 1),
|
|
("ready", 0),
|
|
("expired", 2),
|
|
("ready,expired", 2),
|
|
("unknown,expired", 3),
|
|
]
|
|
for state, num_domains in expected_values:
|
|
with self.subTest(state=state, num_domains=num_domains):
|
|
response = self.app.get(reverse("get_domains_json"), {"status": state})
|
|
self.assertEqual(response.status_code, 200)
|
|
data = response.json
|
|
self.assertEqual(len(data["domains"]), num_domains)
|