Updates to workspace role permissions, invitations

tests/domain/test_invitations.py

@@ -5,15 +5,21 @@ import re
 from atst.domain.invitations import Invitations, InvitationError
 from atst.models.invitation import Status
 
-from tests.factories import WorkspaceFactory, UserFactory, InvitationFactory
+from tests.factories import (
+    WorkspaceFactory,
+    WorkspaceRoleFactory,
+    UserFactory,
+    InvitationFactory,
+)
 
 
 def test_create_invitation():
     workspace = WorkspaceFactory.create()
     user = UserFactory.create()
-    invite = Invitations.create(workspace, workspace.owner, user)
+    ws_role = WorkspaceRoleFactory.create(user=user, workspace=workspace)
+    invite = Invitations.create(ws_role, workspace.owner, user)
     assert invite.user == user
-    assert invite.workspace == workspace
+    assert invite.workspace_role == ws_role
     assert invite.inviter == workspace.owner
     assert invite.status == Status.PENDING
     assert re.match(r"^[\w\-_]+$", invite.token)
@@ -22,22 +28,19 @@ def test_create_invitation():
 def test_accept_invitation():
     workspace = WorkspaceFactory.create()
     user = UserFactory.create()
-    invite = Invitations.create(workspace, workspace.owner, user)
+    ws_role = WorkspaceRoleFactory.create(user=user, workspace=workspace)
+    invite = Invitations.create(ws_role, workspace.owner, user)
     assert invite.is_pending
     accepted_invite = Invitations.accept(invite.token)
     assert accepted_invite.is_accepted
 
 
 def test_accept_expired_invitation():
-    workspace = WorkspaceFactory.create()
     user = UserFactory.create()
     increment = Invitations.EXPIRATION_LIMIT_MINUTES + 1
     expiration_time = datetime.datetime.now() - datetime.timedelta(minutes=increment)
     invite = InvitationFactory.create(
-        workspace_id=workspace.id,
-        user_id=user.id,
-        expiration_time=expiration_time,
-        status=Status.PENDING,
+        user_id=user.id, expiration_time=expiration_time, status=Status.PENDING
     )
     with pytest.raises(InvitationError):
         Invitations.accept(invite.token)
@@ -46,20 +49,14 @@ def test_accept_expired_invitation():
 
 
 def test_accept_rejected_invite():
-    workspace = WorkspaceFactory.create()
     user = UserFactory.create()
-    invite = InvitationFactory.create(
-        workspace_id=workspace.id, user_id=user.id, status=Status.REJECTED
-    )
+    invite = InvitationFactory.create(user_id=user.id, status=Status.REJECTED)
     with pytest.raises(InvitationError):
         Invitations.accept(invite.token)
 
 
 def test_accept_revoked_invite():
-    workspace = WorkspaceFactory.create()
     user = UserFactory.create()
-    invite = InvitationFactory.create(
-        workspace_id=workspace.id, user_id=user.id, status=Status.REVOKED
-    )
+    invite = InvitationFactory.create(user_id=user.id, status=Status.REVOKED)
     with pytest.raises(InvitationError):
         Invitations.accept(invite.token)

tests/domain/test_workspace_users.py

@@ -1,8 +1,14 @@
 from atst.domain.workspace_users import WorkspaceUsers
 from atst.domain.users import Users
-from atst.models.invitation import Status as InvitationStatus
+from atst.models.workspace_role import Status as WorkspaceRoleStatus
+from atst.domain.roles import Roles
 
-from tests.factories import WorkspaceFactory, UserFactory, InvitationFactory
+from tests.factories import (
+    WorkspaceFactory,
+    UserFactory,
+    InvitationFactory,
+    WorkspaceRoleFactory,
+)
 
 
 def test_can_create_new_workspace_user():
@@ -42,17 +48,17 @@ def test_workspace_user_permissions():
     workspace_one = WorkspaceFactory.create()
     workspace_two = WorkspaceFactory.create()
     new_user = UserFactory.create()
-    WorkspaceUsers.add_many(
-        workspace_one.id, [{"id": new_user.id, "workspace_role": "developer"}]
-    )
-    WorkspaceUsers.add_many(
-        workspace_two.id, [{"id": new_user.id, "workspace_role": "developer"}]
-    )
-    InvitationFactory.create(
+    WorkspaceRoleFactory.create(
         workspace=workspace_one,
         user=new_user,
-        inviter=workspace_one.owner,
-        status=InvitationStatus.ACCEPTED,
+        role=Roles.get("developer"),
+        status=WorkspaceRoleStatus.ACTIVE,
+    )
+    WorkspaceRoleFactory.create(
+        workspace=workspace_two,
+        user=new_user,
+        role=Roles.get("developer"),
+        status=WorkspaceRoleStatus.PENDING,
     )
 
     assert WorkspaceUsers.workspace_user_permissions(workspace_one, new_user)

tests/domain/test_workspaces.py

@@ -6,9 +6,14 @@ from atst.domain.workspaces import Workspaces
 from atst.domain.workspace_users import WorkspaceUsers
 from atst.domain.projects import Projects
 from atst.domain.environments import Environments
-from atst.models.invitation import Status as InvitationStatus
+from atst.models.workspace_role import Status as WorkspaceRoleStatus
 
-from tests.factories import RequestFactory, UserFactory, InvitationFactory
+from tests.factories import (
+    RequestFactory,
+    UserFactory,
+    InvitationFactory,
+    WorkspaceRoleFactory,
+)
 
 
 @pytest.fixture(scope="function")
@@ -217,14 +222,9 @@ def test_scoped_workspace_returns_all_projects_for_workspace_admin(
             ["dev", "staging", "prod"],
         )
 
-    admin = Workspaces.add_member(
-        workspace, UserFactory.from_atat_role("default"), "admin"
-    ).user
-    InvitationFactory.create(
-        user=admin,
-        inviter=workspace.owner,
-        workspace=workspace,
-        status=InvitationStatus.ACCEPTED,
+    admin = UserFactory.from_atat_role("default")
+    Workspaces._create_workspace_role(
+        admin, workspace, "admin", status=WorkspaceRoleStatus.ACTIVE
     )
     scoped_workspace = Workspaces.get(admin, workspace.id)
 
@@ -250,23 +250,19 @@ def test_scoped_workspace_returns_all_projects_for_workspace_owner(
     assert len(scoped_workspace.projects[0].environments) == 3
 
 
-def test_for_user_returns_assigned_workspaces_for_user(workspace, workspace_owner):
+def test_for_user_returns_active_workspaces_for_user(workspace, workspace_owner):
     bob = UserFactory.from_atat_role("default")
-    Workspaces.add_member(workspace, bob, "developer")
-    Workspaces.create(RequestFactory.create())
-    InvitationFactory.create(
-        user=bob,
-        inviter=workspace.owner,
-        workspace=workspace,
-        status=InvitationStatus.ACCEPTED,
+    WorkspaceRoleFactory.create(
+        user=bob, workspace=workspace, status=WorkspaceRoleStatus.ACTIVE
     )
+    Workspaces.create(RequestFactory.create())
 
     bobs_workspaces = Workspaces.for_user(bob)
 
     assert len(bobs_workspaces) == 1
 
 
-def test_for_user_does_not_return_unaccepted_workspaces(workspace, workspace_owner):
+def test_for_user_does_not_return_inactive_workspaces(workspace, workspace_owner):
     bob = UserFactory.from_atat_role("default")
     Workspaces.add_member(workspace, bob, "developer")
     Workspaces.create(RequestFactory.create())
@@ -286,22 +282,12 @@ def test_for_user_returns_all_workspaces_for_ccpo(workspace, workspace_owner):
 def test_get_for_update_information():
     workspace_owner = UserFactory.create()
     workspace = Workspaces.create(RequestFactory.create(creator=workspace_owner))
-    InvitationFactory.create(
-        user=workspace_owner,
-        inviter=workspace_owner,
-        workspace=workspace,
-        status=InvitationStatus.ACCEPTED,
-    )
     owner_ws = Workspaces.get_for_update_information(workspace_owner, workspace.id)
     assert workspace == owner_ws
 
     admin = UserFactory.create()
-    Workspaces.add_member(workspace, admin, "admin")
-    InvitationFactory.create(
-        user=admin,
-        inviter=workspace_owner,
-        workspace=workspace,
-        status=InvitationStatus.ACCEPTED,
+    Workspaces._create_workspace_role(
+        admin, workspace, "admin", status=WorkspaceRoleStatus.ACTIVE
     )
     admin_ws = Workspaces.get_for_update_information(admin, workspace.id)
     assert workspace == admin_ws