zydronium/manage.get.gov
1
0
Fork 0
mirror of https://github.com/cisagov/manage.get.gov.git synced 2025-07-24 19:48:36 +02:00
Code Issues Projects Releases Packages Wiki Activity

Fix remaining unit tests

Browse source
This commit is contained in:
zandercymatics 2025-03-07 10:53:15 -07:00
parent 452b8f3588
commit cc08b18bdd
No known key found for this signature in database
GPG key ID: FF4636ABEC9682B7
6 changed files with 147 additions and 138 deletions
Download patch file Download diff file Expand all files Collapse all files

15
src/registrar/decorators.py
View file

@ -109,16 +109,13 @@ def _user_has_permission(user, request, rules, **kwargs):
permission_checks = [ permission_checks = [
(IS_STAFF, lambda: user.is_staff), (IS_STAFF, lambda: user.is_staff),
( (
IS_DOMAIN_MANAGER, IS_DOMAIN_MANAGER,
lambda: ( lambda: (not user.is_org_user(request) and _is_domain_manager(user, **kwargs))
not user.is_org_user(request)
and _is_domain_manager(user, **kwargs)
)
or ( or (
user.is_org_user(request) user.is_org_user(request)
and _is_domain_manager(user, **kwargs) and _is_domain_manager(user, **kwargs)
and _domain_exists_under_portfolio(portfolio, kwargs.get("domain_pk")) and _domain_exists_under_portfolio(portfolio, kwargs.get("domain_pk"))
) ),
), ),
(IS_STAFF_MANAGING_DOMAIN, lambda: _is_staff_managing_domain(request, **kwargs)), (IS_STAFF_MANAGING_DOMAIN, lambda: _is_staff_managing_domain(request, **kwargs)),
(IS_PORTFOLIO_MEMBER, lambda: user.is_org_user(request)), (IS_PORTFOLIO_MEMBER, lambda: user.is_org_user(request)),
@ -130,7 +127,8 @@ def _user_has_permission(user, request, rules, **kwargs):
), ),
( (
HAS_PORTFOLIO_DOMAINS_ANY_PERM, HAS_PORTFOLIO_DOMAINS_ANY_PERM,
lambda: user.is_org_user(request) and user.has_any_domains_portfolio_permission(portfolio) lambda: user.is_org_user(request)
and user.has_any_domains_portfolio_permission(portfolio)
and _domain_exists_under_portfolio(portfolio, kwargs.get("domain_pk")), and _domain_exists_under_portfolio(portfolio, kwargs.get("domain_pk")),
), ),
( (
@ -150,7 +148,8 @@ def _user_has_permission(user, request, rules, **kwargs):
), ),
( (
HAS_PORTFOLIO_DOMAIN_REQUESTS_ANY_PERM, HAS_PORTFOLIO_DOMAIN_REQUESTS_ANY_PERM,
lambda: user.is_org_user(request) and user.has_any_requests_portfolio_permission(portfolio) lambda: user.is_org_user(request)
and user.has_any_requests_portfolio_permission(portfolio)
and _domain_request_exists_under_portfolio(portfolio, kwargs.get("domain_request_pk")), and _domain_request_exists_under_portfolio(portfolio, kwargs.get("domain_request_pk")),
), ),
( (

171
src/registrar/tests/test_resource_access.py
View file

@ -33,62 +33,60 @@ class TestPortfolioResourceAccess(MockDbForIndividualTests):
def setUp(self): def setUp(self):
super().setUp() super().setUp()
# Create portfolios # Create portfolios
self.portfolio = Portfolio.objects.create( self.portfolio = Portfolio.objects.create(creator=self.user, organization_name="Test Portfolio")
creator=self.user, organization_name="Test Portfolio"
)
self.other_portfolio = Portfolio.objects.create( self.other_portfolio = Portfolio.objects.create(
creator=self.custom_staffuser, organization_name="Other Portfolio" creator=self.custom_staffuser, organization_name="Other Portfolio"
) )
# Create domain requests # Create domain requests
self.domain_request = completed_domain_request(name="eggnog.gov", user=self.user, portfolio=self.portfolio) self.domain_request = completed_domain_request(name="eggnog.gov", user=self.user, portfolio=self.portfolio)
self.other_domain_request = completed_domain_request( self.other_domain_request = completed_domain_request(
name="christmas.gov", user=self.tired_user, portfolio=self.other_portfolio name="christmas.gov", user=self.tired_user, portfolio=self.other_portfolio
) )
# Create domains # Create domains
self.approved_domain_request_1 = completed_domain_request( self.approved_domain_request_1 = completed_domain_request(
name="done_1.gov", user=self.tired_user, portfolio=self.portfolio, status=DomainRequest.DomainRequestStatus.IN_REVIEW name="done_1.gov",
user=self.tired_user,
portfolio=self.portfolio,
status=DomainRequest.DomainRequestStatus.IN_REVIEW,
) )
self.approved_domain_request_2 = completed_domain_request( self.approved_domain_request_2 = completed_domain_request(
name="done_2.gov", user=self.tired_user, portfolio=self.other_portfolio, status=DomainRequest.DomainRequestStatus.IN_REVIEW name="done_2.gov",
user=self.tired_user,
portfolio=self.other_portfolio,
status=DomainRequest.DomainRequestStatus.IN_REVIEW,
) )
self.approved_domain_request_1.approve() self.approved_domain_request_1.approve()
self.approved_domain_request_2.approve() self.approved_domain_request_2.approve()
self.domain = self.approved_domain_request_1.approved_domain self.domain = self.approved_domain_request_1.approved_domain
self.other_domain = self.approved_domain_request_2.approved_domain self.other_domain = self.approved_domain_request_2.approved_domain
# Create portfolio permissions # Create portfolio permissions
self.user_permission = UserPortfolioPermission.objects.create( self.user_permission = UserPortfolioPermission.objects.create(
user=self.user, user=self.user, portfolio=self.portfolio, roles=[UserPortfolioRoleChoices.ORGANIZATION_ADMIN]
portfolio=self.portfolio,
roles=[UserPortfolioRoleChoices.ORGANIZATION_ADMIN]
) )
self.other_user_permission = UserPortfolioPermission.objects.create( self.other_user_permission = UserPortfolioPermission.objects.create(
user=self.tired_user, user=self.tired_user, portfolio=self.other_portfolio, roles=[UserPortfolioRoleChoices.ORGANIZATION_ADMIN]
portfolio=self.other_portfolio,
roles=[UserPortfolioRoleChoices.ORGANIZATION_ADMIN]
) )
# Create portfolio invitations # Create portfolio invitations
self.portfolio_invitation = PortfolioInvitation.objects.create( self.portfolio_invitation = PortfolioInvitation.objects.create(
email="invited@example.com", email="invited@example.com",
portfolio=self.portfolio, portfolio=self.portfolio,
roles=[UserPortfolioRoleChoices.ORGANIZATION_ADMIN], roles=[UserPortfolioRoleChoices.ORGANIZATION_ADMIN],
status=PortfolioInvitation.PortfolioInvitationStatus.INVITED status=PortfolioInvitation.PortfolioInvitationStatus.INVITED,
) )
self.other_portfolio_invitation = PortfolioInvitation.objects.create( self.other_portfolio_invitation = PortfolioInvitation.objects.create(
email="other-invited@example.com", email="other-invited@example.com",
portfolio=self.other_portfolio, portfolio=self.other_portfolio,
roles=[UserPortfolioRoleChoices.ORGANIZATION_ADMIN], roles=[UserPortfolioRoleChoices.ORGANIZATION_ADMIN],
status=PortfolioInvitation.PortfolioInvitationStatus.INVITED status=PortfolioInvitation.PortfolioInvitationStatus.INVITED,
) )
# Domain request tests # Domain request tests
@ -158,43 +156,39 @@ class TestPortfolioResourceAccess(MockDbForIndividualTests):
class TestPortfolioDomainRequestViewAccess(MockDbForIndividualTests): class TestPortfolioDomainRequestViewAccess(MockDbForIndividualTests):
"""Tests for domain request views to ensure users can only access domain requests in their portfolio.""" """Tests for domain request views to ensure users can only access domain requests in their portfolio."""
def setUp(self): def setUp(self):
super().setUp() super().setUp()
self.client = Client() self.client = Client()
self.client.force_login(self.user) self.client.force_login(self.user)
# Create portfolios # Create portfolios
self.portfolio = Portfolio.objects.create( self.portfolio = Portfolio.objects.create(creator=self.user, organization_name="Test Portfolio")
creator=self.user, organization_name="Test Portfolio" self.other_portfolio = Portfolio.objects.create(creator=self.tired_user, organization_name="Other Portfolio")
)
self.other_portfolio = Portfolio.objects.create(
creator=self.tired_user, organization_name="Other Portfolio"
)
# Create domain requests # Create domain requests
self.domain_request = completed_domain_request( self.domain_request = completed_domain_request(
name="test-domain.gov", name="test-domain.gov",
portfolio=self.portfolio, portfolio=self.portfolio,
status=DomainRequest.DomainRequestStatus.STARTED, status=DomainRequest.DomainRequestStatus.STARTED,
user=self.user user=self.user,
) )
self.other_domain_request = completed_domain_request( self.other_domain_request = completed_domain_request(
name="other-domain.gov", name="other-domain.gov",
portfolio=self.other_portfolio, portfolio=self.other_portfolio,
status=DomainRequest.DomainRequestStatus.STARTED, status=DomainRequest.DomainRequestStatus.STARTED,
user=self.tired_user user=self.tired_user,
) )
# Give user permission to view all requests # Give user permission to view all requests
self.user_permission = UserPortfolioPermission.objects.create( self.user_permission = UserPortfolioPermission.objects.create(
user=self.user, user=self.user,
portfolio=self.portfolio, portfolio=self.portfolio,
roles=[UserPortfolioRoleChoices.ORGANIZATION_MEMBER], roles=[UserPortfolioRoleChoices.ORGANIZATION_MEMBER],
additional_permissions=[UserPortfolioPermissionChoices.VIEW_ALL_REQUESTS] additional_permissions=[UserPortfolioPermissionChoices.VIEW_ALL_REQUESTS],
) )
# Setup session for portfolio views # Setup session for portfolio views
session = self.client.session session = self.client.session
session["portfolio"] = self.portfolio session["portfolio"] = self.portfolio
@ -206,31 +200,29 @@ class TestPortfolioDomainRequestViewAccess(MockDbForIndividualTests):
def test_domain_request_view_same_portfolio(self): def test_domain_request_view_same_portfolio(self):
"""Test that user can access domain requests in their portfolio.""" """Test that user can access domain requests in their portfolio."""
# With just the view all permission, access should be denied # With just the view all permission, access should be denied
response = self.client.get(reverse("edit-domain-request", kwargs={ response = self.client.get(reverse("edit-domain-request", kwargs={"domain_request_pk": self.domain_request.pk}))
"domain_request_pk": self.domain_request.pk
}))
self.assertEqual(response.status_code, 403) self.assertEqual(response.status_code, 403)
# But with the edit permission, the user should be able to access this domain request # But with the edit permission, the user should be able to access this domain request
self.user_permission.additional_permissions = [ self.user_permission.additional_permissions = [
UserPortfolioPermissionChoices.VIEW_ALL_REQUESTS, UserPortfolioPermissionChoices.VIEW_ALL_REQUESTS,
UserPortfolioPermissionChoices.EDIT_REQUESTS UserPortfolioPermissionChoices.EDIT_REQUESTS,
] ]
self.user_permission.save() self.user_permission.save()
self.user_permission.refresh_from_db() self.user_permission.refresh_from_db()
response = self.client.get(reverse("edit-domain-request", kwargs={ response = self.client.get(
"domain_request_pk": self.domain_request.pk reverse("edit-domain-request", kwargs={"domain_request_pk": self.domain_request.pk}), follow=True
}), follow=True) )
self.assertEqual(response.status_code, 200) self.assertEqual(response.status_code, 200)
@override_flag("organization_feature", active=True) @override_flag("organization_feature", active=True)
@override_flag("organization_requests", active=True) @override_flag("organization_requests", active=True)
@less_console_noise_decorator @less_console_noise_decorator
def test_domain_request_view_different_portfolio(self): def test_domain_request_view_different_portfolio(self):
"""Test that user cannot access domain request not in their portfolio.""" """Test that user cannot access domain request not in their portfolio."""
response = self.client.get(reverse("edit-domain-request", kwargs={ response = self.client.get(
"domain_request_pk": self.other_domain_request.pk reverse("edit-domain-request", kwargs={"domain_request_pk": self.other_domain_request.pk})
})) )
self.assertEqual(response.status_code, 403) self.assertEqual(response.status_code, 403)
@override_flag("organization_feature", active=True) @override_flag("organization_feature", active=True)
@ -238,65 +230,61 @@ class TestPortfolioDomainRequestViewAccess(MockDbForIndividualTests):
@less_console_noise_decorator @less_console_noise_decorator
def test_domain_request_viewonly_same_portfolio(self): def test_domain_request_viewonly_same_portfolio(self):
"""Test that user can access view-only domain request in their portfolio.""" """Test that user can access view-only domain request in their portfolio."""
response = self.client.get(reverse("domain-request-status-viewonly", kwargs={ response = self.client.get(
"domain_request_pk": self.domain_request.pk reverse("domain-request-status-viewonly", kwargs={"domain_request_pk": self.domain_request.pk})
})) )
self.assertEqual(response.status_code, 200) self.assertEqual(response.status_code, 200)
@override_flag("organization_feature", active=True) @override_flag("organization_feature", active=True)
@override_flag("organization_requests", active=True) @override_flag("organization_requests", active=True)
@less_console_noise_decorator @less_console_noise_decorator
def test_domain_request_viewonly_different_portfolio(self): def test_domain_request_viewonly_different_portfolio(self):
"""Test that user cannot access view-only domain request not in their portfolio.""" """Test that user cannot access view-only domain request not in their portfolio."""
response = self.client.get(reverse("domain-request-status-viewonly", kwargs={ response = self.client.get(
"domain_request_pk": self.other_domain_request.pk reverse("domain-request-status-viewonly", kwargs={"domain_request_pk": self.other_domain_request.pk})
})) )
self.assertEqual(response.status_code, 403) self.assertEqual(response.status_code, 403)
class TestPortfolioDomainViewAccess(MockDbForIndividualTests): class TestPortfolioDomainViewAccess(MockDbForIndividualTests):
"""Tests for domain views to ensure users can only access domains in their portfolio.""" """Tests for domain views to ensure users can only access domains in their portfolio."""
def setUp(self): def setUp(self):
super().setUp() super().setUp()
self.client = Client() self.client = Client()
self.client.force_login(self.user) self.client.force_login(self.user)
# Create portfolios # Create portfolios
self.portfolio = Portfolio.objects.create( self.portfolio = Portfolio.objects.create(creator=self.user, organization_name="Test Portfolio")
creator=self.user, organization_name="Test Portfolio" self.other_portfolio = Portfolio.objects.create(creator=self.tired_user, organization_name="Other Portfolio")
)
self.other_portfolio = Portfolio.objects.create(
creator=self.tired_user, organization_name="Other Portfolio"
)
# Create domains through domain requests # Create domains through domain requests
self.domain_request = completed_domain_request( self.domain_request = completed_domain_request(
name="test-domain.gov", name="test-domain.gov",
portfolio=self.portfolio, portfolio=self.portfolio,
status=DomainRequest.DomainRequestStatus.IN_REVIEW, status=DomainRequest.DomainRequestStatus.IN_REVIEW,
user=self.user user=self.user,
) )
self.domain_request.approve() self.domain_request.approve()
self.domain = self.domain_request.approved_domain self.domain = self.domain_request.approved_domain
self.other_domain_request = completed_domain_request( self.other_domain_request = completed_domain_request(
name="other-domain.gov", name="other-domain.gov",
portfolio=self.other_portfolio, portfolio=self.other_portfolio,
status=DomainRequest.DomainRequestStatus.IN_REVIEW, status=DomainRequest.DomainRequestStatus.IN_REVIEW,
user=self.user user=self.user,
) )
self.other_domain_request.approve() self.other_domain_request.approve()
self.other_domain = self.other_domain_request.approved_domain self.other_domain = self.other_domain_request.approved_domain
# Give user permission to view all domains # Give user permission to view all domains
self.user_permission = UserPortfolioPermission.objects.create( self.user_permission = UserPortfolioPermission.objects.create(
user=self.user, user=self.user,
portfolio=self.portfolio, portfolio=self.portfolio,
roles=[UserPortfolioRoleChoices.ORGANIZATION_MEMBER], roles=[UserPortfolioRoleChoices.ORGANIZATION_MEMBER],
additional_permissions=[UserPortfolioPermissionChoices.VIEW_ALL_DOMAINS] additional_permissions=[UserPortfolioPermissionChoices.VIEW_ALL_DOMAINS],
) )
# Setup session for portfolio views # Setup session for portfolio views
session = self.client.session session = self.client.session
session["portfolio"] = self.portfolio session["portfolio"] = self.portfolio
@ -306,49 +294,38 @@ class TestPortfolioDomainViewAccess(MockDbForIndividualTests):
@less_console_noise_decorator @less_console_noise_decorator
def test_domain_view_same_portfolio(self): def test_domain_view_same_portfolio(self):
"""Test that user can access domain in their portfolio.""" """Test that user can access domain in their portfolio."""
response = self.client.get(reverse("domain", kwargs={ response = self.client.get(reverse("domain", kwargs={"domain_pk": self.domain.pk}))
"domain_pk": self.domain.pk
}))
self.assertEqual(response.status_code, 200) self.assertEqual(response.status_code, 200)
@override_flag("organization_feature", active=True) @override_flag("organization_feature", active=True)
@less_console_noise_decorator @less_console_noise_decorator
def test_domain_view_different_portfolio(self): def test_domain_view_different_portfolio(self):
"""Test that user cannot access domain not in their portfolio.""" """Test that user cannot access domain not in their portfolio."""
response = self.client.get(reverse("domain", kwargs={ response = self.client.get(reverse("domain", kwargs={"domain_pk": self.other_domain.pk}))
"domain_pk": self.other_domain.pk
}))
self.assertEqual(response.status_code, 403) self.assertEqual(response.status_code, 403)
class TestPortfolioMemberViewAccess(MockDbForIndividualTests): class TestPortfolioMemberViewAccess(MockDbForIndividualTests):
"""Tests for member views to ensure users can only access members in their portfolio.""" """Tests for member views to ensure users can only access members in their portfolio."""
def setUp(self): def setUp(self):
super().setUp() super().setUp()
self.client = Client() self.client = Client()
self.client.force_login(self.user) self.client.force_login(self.user)
# Create portfolios
self.portfolio = Portfolio.objects.create(
creator=self.user, organization_name="Test Portfolio"
)
self.other_portfolio = Portfolio.objects.create(
creator=self.tired_user, organization_name="Other Portfolio"
)
# Create portfolios
self.portfolio = Portfolio.objects.create(creator=self.user, organization_name="Test Portfolio")
self.other_portfolio = Portfolio.objects.create(creator=self.tired_user, organization_name="Other Portfolio")
# Create portfolio permissions # Create portfolio permissions
self.member_permission = UserPortfolioPermission.objects.create( self.member_permission = UserPortfolioPermission.objects.create(
user=self.meoward_user, user=self.meoward_user, portfolio=self.portfolio, roles=[UserPortfolioRoleChoices.ORGANIZATION_MEMBER]
portfolio=self.portfolio,
roles=[UserPortfolioRoleChoices.ORGANIZATION_MEMBER]
) )
self.other_member_permission = UserPortfolioPermission.objects.create( self.other_member_permission = UserPortfolioPermission.objects.create(
user=self.lebowski_user, user=self.lebowski_user,
portfolio=self.other_portfolio, portfolio=self.other_portfolio,
roles=[UserPortfolioRoleChoices.ORGANIZATION_MEMBER] roles=[UserPortfolioRoleChoices.ORGANIZATION_MEMBER],
) )
# Give user permission to view/edit members # Give user permission to view/edit members
@ -357,7 +334,7 @@ class TestPortfolioMemberViewAccess(MockDbForIndividualTests):
portfolio=self.portfolio, portfolio=self.portfolio,
roles=[UserPortfolioRoleChoices.ORGANIZATION_ADMIN], roles=[UserPortfolioRoleChoices.ORGANIZATION_ADMIN],
) )
# Setup session for portfolio views # Setup session for portfolio views
session = self.client.session session = self.client.session
session["portfolio"] = self.portfolio session["portfolio"] = self.portfolio
@ -368,17 +345,13 @@ class TestPortfolioMemberViewAccess(MockDbForIndividualTests):
@less_console_noise_decorator @less_console_noise_decorator
def test_member_view_same_portfolio(self): def test_member_view_same_portfolio(self):
"""Test that user can access member in their portfolio.""" """Test that user can access member in their portfolio."""
response = self.client.get(reverse("member", kwargs={ response = self.client.get(reverse("member", kwargs={"member_pk": self.member_permission.pk}))
"member_pk": self.member_permission.pk
}))
self.assertEqual(response.status_code, 200) self.assertEqual(response.status_code, 200)
@override_flag("organization_feature", active=True) @override_flag("organization_feature", active=True)
@override_flag("organization_members", active=True) @override_flag("organization_members", active=True)
@less_console_noise_decorator @less_console_noise_decorator
def test_member_view_different_portfolio(self): def test_member_view_different_portfolio(self):
"""Test that user cannot access member not in their portfolio.""" """Test that user cannot access member not in their portfolio."""
response = self.client.get(reverse("member", kwargs={ response = self.client.get(reverse("member", kwargs={"member_pk": self.other_member_permission.pk}))
"member_pk": self.other_member_permission.pk
}))
self.assertEqual(response.status_code, 403) self.assertEqual(response.status_code, 403)

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

@ -30,7 +30,7 @@ SAMPLE_KWARGS = {
"portfolio_id": "1", "portfolio_id": "1",
"user_id": "1", "user_id": "1",
"member_pk": "1", "member_pk": "1",
"invitedmember_pk": "1" "invitedmember_pk": "1",
} }
# Our test suite will ignore some namespaces. # Our test suite will ignore some namespaces.

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

@ -1016,7 +1016,9 @@ class TestPortfolio(WebTest):
# Verify the page can be accessed # Verify the page can be accessed
self.client.force_login(self.user) self.client.force_login(self.user)
response = self.client.get(reverse("invitedmember", kwargs={"invitedmember_pk": portfolio_invitation.pk}), follow=True) response = self.client.get(
reverse("invitedmember", kwargs={"invitedmember_pk": portfolio_invitation.pk}), follow=True
)
self.assertEqual(response.status_code, 200) self.assertEqual(response.status_code, 200)
# Assert text within the page is correct # Assert text within the page is correct
@ -1054,7 +1056,9 @@ class TestPortfolio(WebTest):
# Verify the page can be accessed # Verify the page can be accessed
self.client.force_login(self.user) self.client.force_login(self.user)
response = self.client.get(reverse("invitedmember", kwargs={"invitedmember_pk": portfolio_invitation.pk}), follow=True) response = self.client.get(
reverse("invitedmember", kwargs={"invitedmember_pk": portfolio_invitation.pk}), follow=True
)
self.assertEqual(response.status_code, 200) self.assertEqual(response.status_code, 200)
# Assert text within the page is correct # Assert text within the page is correct
@ -1738,7 +1742,8 @@ class TestPortfolioMemberDeleteView(WebTest):
self.client.force_login(self.user) self.client.force_login(self.user)
# We check X_REQUESTED_WITH bc those return JSON responses # We check X_REQUESTED_WITH bc those return JSON responses
response = self.client.post( response = self.client.post(
reverse("member-delete", kwargs={"member_pk": admin_perm_user.pk}), HTTP_X_REQUESTED_WITH="XMLHttpRequest" reverse("member-delete", kwargs={"member_pk": admin_perm_user.pk}),
HTTP_X_REQUESTED_WITH="XMLHttpRequest",
) )
self.assertEqual(response.status_code, 400) self.assertEqual(response.status_code, 400)
@ -2066,7 +2071,9 @@ class TestPortfolioMemberDeleteView(WebTest):
# Location is used for a 3xx HTTP status code to indicate that the URL was redirected # Location is used for a 3xx HTTP status code to indicate that the URL was redirected
# and then confirm that we're still on the Manage Members page # and then confirm that we're still on the Manage Members page
self.assertEqual(response.headers["Location"], reverse("member", kwargs={"member_pk": admin_perm_user.pk})) self.assertEqual(
response.headers["Location"], reverse("member", kwargs={"member_pk": admin_perm_user.pk})
)
class TestPortfolioInvitedMemberDeleteView(WebTest): class TestPortfolioInvitedMemberDeleteView(WebTest):
@ -2772,7 +2779,9 @@ class TestPortfolioMemberDomainsEditView(TestWithUser, WebTest):
self.assertEqual(UserDomainRole.objects.filter(user=self.user, role=UserDomainRole.Roles.MANAGER).count(), 0) self.assertEqual(UserDomainRole.objects.filter(user=self.user, role=UserDomainRole.Roles.MANAGER).count(), 0)
# Check for an error message and a redirect to edit form # Check for an error message and a redirect to edit form
self.assertRedirects(response, reverse("member-domains-edit", kwargs={"member_pk": self.portfolio_permission.pk})) self.assertRedirects(
response, reverse("member-domains-edit", kwargs={"member_pk": self.portfolio_permission.pk})
)
messages = list(response.wsgi_request._messages) messages = list(response.wsgi_request._messages)
self.assertEqual(len(messages), 1) self.assertEqual(len(messages), 1)
self.assertEqual( self.assertEqual(
@ -2849,7 +2858,9 @@ class TestPortfolioInvitedMemberEditDomainsView(TestWithUser, WebTest):
"""Tests that the portfolio invited member domains edit view is accessible.""" """Tests that the portfolio invited member domains edit view is accessible."""
self.client.force_login(self.user) self.client.force_login(self.user)
response = self.client.get(reverse("invitedmember-domains-edit", kwargs={"invitedmember_pk": self.invitation.id})) response = self.client.get(
reverse("invitedmember-domains-edit", kwargs={"invitedmember_pk": self.invitation.id})
)
# Make sure the page loaded, and that we're on the right page # Make sure the page loaded, and that we're on the right page
self.assertEqual(response.status_code, 200) self.assertEqual(response.status_code, 200)
@ -2862,7 +2873,9 @@ class TestPortfolioInvitedMemberEditDomainsView(TestWithUser, WebTest):
"""Tests that the portfolio invited member domains edit view is not accessible to user with no perms.""" """Tests that the portfolio invited member domains edit view is not accessible to user with no perms."""
self.client.force_login(self.user_no_perms) self.client.force_login(self.user_no_perms)
response = self.client.get(reverse("invitedmember-domains-edit", kwargs={"invitedmember_pk": self.invitation.id})) response = self.client.get(
reverse("invitedmember-domains-edit", kwargs={"invitedmember_pk": self.invitation.id})
)
# Make sure the request returns forbidden # Make sure the request returns forbidden
self.assertEqual(response.status_code, 403) self.assertEqual(response.status_code, 403)
@ -2874,7 +2887,9 @@ class TestPortfolioInvitedMemberEditDomainsView(TestWithUser, WebTest):
"""Tests that the portfolio invited member domains edit view is not accessible when no authenticated user.""" """Tests that the portfolio invited member domains edit view is not accessible when no authenticated user."""
self.client.logout() self.client.logout()
response = self.client.get(reverse("invitedmember-domains-edit", kwargs={"invitedmember_pk": self.invitation.id})) response = self.client.get(
reverse("invitedmember-domains-edit", kwargs={"invitedmember_pk": self.invitation.id})
)
# Make sure the request returns redirect to openid login # Make sure the request returns redirect to openid login
self.assertEqual(response.status_code, 302) # Redirect to openid login self.assertEqual(response.status_code, 302) # Redirect to openid login
@ -2914,7 +2929,9 @@ class TestPortfolioInvitedMemberEditDomainsView(TestWithUser, WebTest):
) )
# Check for a success message and a redirect # Check for a success message and a redirect
self.assertRedirects(response, reverse("invitedmember-domains", kwargs={"invitedmember_pk": self.invitation.pk})) self.assertRedirects(
response, reverse("invitedmember-domains", kwargs={"invitedmember_pk": self.invitation.pk})
)
messages = list(response.wsgi_request._messages) messages = list(response.wsgi_request._messages)
self.assertEqual(len(messages), 1) self.assertEqual(len(messages), 1)
self.assertEqual(str(messages[0]), "The domain assignment changes have been saved.") self.assertEqual(str(messages[0]), "The domain assignment changes have been saved.")
@ -2971,7 +2988,9 @@ class TestPortfolioInvitedMemberEditDomainsView(TestWithUser, WebTest):
) )
# Check for a success message and a redirect # Check for a success message and a redirect
self.assertRedirects(response, reverse("invitedmember-domains", kwargs={"invitedmember_pk": self.invitation.pk})) self.assertRedirects(
response, reverse("invitedmember-domains", kwargs={"invitedmember_pk": self.invitation.pk})
)
@less_console_noise_decorator @less_console_noise_decorator
@override_flag("organization_feature", active=True) @override_flag("organization_feature", active=True)
@ -3015,7 +3034,9 @@ class TestPortfolioInvitedMemberEditDomainsView(TestWithUser, WebTest):
) )
# Check for a success message and a redirect # Check for a success message and a redirect
self.assertRedirects(response, reverse("invitedmember-domains", kwargs={"invitedmember_pk": self.invitation.pk})) self.assertRedirects(
response, reverse("invitedmember-domains", kwargs={"invitedmember_pk": self.invitation.pk})
)
# assert that send_domain_invitation_email is not called # assert that send_domain_invitation_email is not called
mock_send_domain_email.assert_not_called() mock_send_domain_email.assert_not_called()
@ -3035,7 +3056,9 @@ class TestPortfolioInvitedMemberEditDomainsView(TestWithUser, WebTest):
self.assertEqual(DomainInvitation.objects.count(), 0) self.assertEqual(DomainInvitation.objects.count(), 0)
# Check for an error message and a redirect # Check for an error message and a redirect
self.assertRedirects(response, reverse("invitedmember-domains", kwargs={"invitedmember_pk": self.invitation.pk})) self.assertRedirects(
response, reverse("invitedmember-domains", kwargs={"invitedmember_pk": self.invitation.pk})
)
messages = list(response.wsgi_request._messages) messages = list(response.wsgi_request._messages)
self.assertEqual(len(messages), 1) self.assertEqual(len(messages), 1)
self.assertEqual( self.assertEqual(
@ -3058,7 +3081,9 @@ class TestPortfolioInvitedMemberEditDomainsView(TestWithUser, WebTest):
self.assertEqual(DomainInvitation.objects.count(), 0) self.assertEqual(DomainInvitation.objects.count(), 0)
# Check for an error message and a redirect # Check for an error message and a redirect
self.assertRedirects(response, reverse("invitedmember-domains", kwargs={"invitedmember_pk": self.invitation.pk})) self.assertRedirects(
response, reverse("invitedmember-domains", kwargs={"invitedmember_pk": self.invitation.pk})
)
messages = list(response.wsgi_request._messages) messages = list(response.wsgi_request._messages)
self.assertEqual(len(messages), 1) self.assertEqual(len(messages), 1)
self.assertEqual( self.assertEqual(
@ -3078,7 +3103,9 @@ class TestPortfolioInvitedMemberEditDomainsView(TestWithUser, WebTest):
self.assertEqual(DomainInvitation.objects.count(), 0) self.assertEqual(DomainInvitation.objects.count(), 0)
# Check for an info message and a redirect # Check for an info message and a redirect
self.assertRedirects(response, reverse("invitedmember-domains", kwargs={"invitedmember_pk": self.invitation.pk})) self.assertRedirects(
response, reverse("invitedmember-domains", kwargs={"invitedmember_pk": self.invitation.pk})
)
messages = list(response.wsgi_request._messages) messages = list(response.wsgi_request._messages)
self.assertEqual(len(messages), 1) self.assertEqual(len(messages), 1)
self.assertEqual(str(messages[0]), "The domain assignment changes have been saved.") self.assertEqual(str(messages[0]), "The domain assignment changes have been saved.")
@ -3106,7 +3133,9 @@ class TestPortfolioInvitedMemberEditDomainsView(TestWithUser, WebTest):
) )
# Check for an error message and a redirect to edit form # Check for an error message and a redirect to edit form
self.assertRedirects(response, reverse("invitedmember-domains-edit", kwargs={"invitedmember_pk": self.invitation.pk})) self.assertRedirects(
response, reverse("invitedmember-domains-edit", kwargs={"invitedmember_pk": self.invitation.pk})
)
messages = list(response.wsgi_request._messages) messages = list(response.wsgi_request._messages)
self.assertEqual(len(messages), 1) self.assertEqual(len(messages), 1)
self.assertEqual( self.assertEqual(
@ -4577,7 +4606,7 @@ class TestPortfolioInvitedMemberEditView(WebTest):
# Test updating invitation permissions # Test updating invitation permissions
response = self.client.post( response = self.client.post(
reverse("invitedmember-permissions", kwargs={"member_pk": self.invitation.id}), reverse("invitedmember-permissions", kwargs={"invitedmember_pk": self.invitation.id}),
{ {
"role": UserPortfolioRoleChoices.ORGANIZATION_ADMIN, "role": UserPortfolioRoleChoices.ORGANIZATION_ADMIN,
}, },

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

@ -2796,7 +2796,7 @@ class DomainRequestTests(TestWithUser, WebTest):
self.assertEqual(intro_page.status_code, 200) self.assertEqual(intro_page.status_code, 200)
# This user should also be allowed to edit existing ones # This user should also be allowed to edit existing ones
domain_request = completed_domain_request(user=self.user) domain_request = completed_domain_request(user=self.user, portfolio=portfolio)
edit_page = self.app.get( edit_page = self.app.get(
reverse("edit-domain-request", kwargs={"domain_request_pk": domain_request.pk}) reverse("edit-domain-request", kwargs={"domain_request_pk": domain_request.pk})
).follow() ).follow()
@ -2904,7 +2904,9 @@ class DomainRequestTestDifferentStatuses(TestWithUser, WebTest):
roles=[UserPortfolioRoleChoices.ORGANIZATION_ADMIN], roles=[UserPortfolioRoleChoices.ORGANIZATION_ADMIN],
additional_permissions=[UserPortfolioPermissionChoices.EDIT_REQUESTS], additional_permissions=[UserPortfolioPermissionChoices.EDIT_REQUESTS],
) )
domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.SUBMITTED, user=self.user) domain_request = completed_domain_request(
status=DomainRequest.DomainRequestStatus.SUBMITTED, user=self.user, portfolio=portfolio
)
domain_request.save() 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}")
@ -3044,13 +3046,17 @@ class TestDomainRequestWizard(TestWithUser, WebTest):
roles=[UserPortfolioRoleChoices.ORGANIZATION_ADMIN], roles=[UserPortfolioRoleChoices.ORGANIZATION_ADMIN],
additional_permissions=[UserPortfolioPermissionChoices.EDIT_REQUESTS], additional_permissions=[UserPortfolioPermissionChoices.EDIT_REQUESTS],
) )
domain_request.portfolio = portfolio
domain_request.save()
domain_request.refresh_from_db()
# Check portfolio-specific breadcrumb # Check portfolio-specific breadcrumb
portfolio_page = self.app.get(f"/domain-request/{domain_request.id}/edit/").follow() portfolio_page = self.app.get(f"/domain-request/{domain_request.id}/edit/").follow()
self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id) self.app.set_cookie(settings.SESSION_COOKIE_NAME, session_id)
self.assertContains(portfolio_page, "Domain requests") self.assertContains(portfolio_page, "Domain requests")
domain_request.portfolio = None
domain_request.save()
# Clean up portfolio # Clean up portfolio
permission.delete() permission.delete()
portfolio.delete() portfolio.delete()
@ -3177,15 +3183,6 @@ class TestDomainRequestWizard(TestWithUser, WebTest):
- The user does not see the Domain and Domain requests buttons - The user does not see the Domain and Domain requests buttons
""" """
# This should unlock 4 steps by default.
# Purpose, .gov domain, current websites, and requirements for operating
domain_request = completed_domain_request(
status=DomainRequest.DomainRequestStatus.STARTED,
user=self.user,
)
domain_request.anything_else = None
domain_request.save()
federal_agency = FederalAgency.objects.get(agency="Non-Federal Agency") federal_agency = FederalAgency.objects.get(agency="Non-Federal Agency")
# Add a portfolio # Add a portfolio
portfolio = Portfolio.objects.create( portfolio = Portfolio.objects.create(
@ -3203,6 +3200,14 @@ class TestDomainRequestWizard(TestWithUser, WebTest):
], ],
) )
# This should unlock 4 steps by default.
# Purpose, .gov domain, current websites, and requirements for operating
domain_request = completed_domain_request(
status=DomainRequest.DomainRequestStatus.STARTED, user=self.user, portfolio=portfolio
)
domain_request.anything_else = None
domain_request.save()
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 # django-webtest does not handle cookie-based sessions well because it keeps
# resetting the session key on each new request, thus destroying the concept # resetting the session key on each new request, thus destroying the concept
@ -3247,6 +3252,8 @@ class TestDomainRequestWizard(TestWithUser, WebTest):
self.fail(f"Expected a redirect, but got a different response: {response}") self.fail(f"Expected a redirect, but got a different response: {response}")
# Data cleanup # Data cleanup
domain_request.portfolio = None
domain_request.save()
user_portfolio_permission.delete() user_portfolio_permission.delete()
portfolio.delete() portfolio.delete()
federal_agency.delete() federal_agency.delete()
@ -3311,7 +3318,9 @@ class TestPortfolioDomainRequestViewonly(TestWithUser, WebTest):
user=self.user, portfolio=portfolio, roles=[UserPortfolioRoleChoices.ORGANIZATION_ADMIN] user=self.user, portfolio=portfolio, roles=[UserPortfolioRoleChoices.ORGANIZATION_ADMIN]
) )
dummy_user, _ = User.objects.get_or_create(username="testusername123456") dummy_user, _ = User.objects.get_or_create(username="testusername123456")
domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.SUBMITTED, user=dummy_user) domain_request = completed_domain_request(
status=DomainRequest.DomainRequestStatus.SUBMITTED, user=dummy_user, portfolio=portfolio
)
domain_request.save() domain_request.save()
detail_page = self.app.get(f"/domain-request/viewonly/{domain_request.id}") detail_page = self.app.get(f"/domain-request/viewonly/{domain_request.id}")

1
src/registrar/views/portfolios.py
View file

@ -12,7 +12,6 @@ from registrar.decorators import (
HAS_PORTFOLIO_DOMAINS_ANY_PERM, HAS_PORTFOLIO_DOMAINS_ANY_PERM,
HAS_PORTFOLIO_MEMBERS_ANY_PERM, HAS_PORTFOLIO_MEMBERS_ANY_PERM,
HAS_PORTFOLIO_MEMBERS_EDIT, HAS_PORTFOLIO_MEMBERS_EDIT,
HAS_PORTFOLIO_MEMBERS_VIEW,
IS_PORTFOLIO_MEMBER, IS_PORTFOLIO_MEMBER,
grant_access, grant_access,
) )