workspace -> portfolio everywhere

tests/routes/portfolios/test_applications.py

@@ -2,132 +2,132 @@ from flask import url_for
 
 from tests.factories import (
     UserFactory,
-    WorkspaceFactory,
-    WorkspaceRoleFactory,
+    PortfolioFactory,
+    PortfolioRoleFactory,
     EnvironmentRoleFactory,
     EnvironmentFactory,
     ApplicationFactory,
 )
 
 from atst.domain.applications import Applications
-from atst.domain.workspaces import Workspaces
+from atst.domain.portfolios import Portfolios
 from atst.domain.roles import Roles
-from atst.models.workspace_role import Status as WorkspaceRoleStatus
+from atst.models.portfolio_role import Status as PortfolioRoleStatus
 
 
 def test_user_with_permission_has_budget_report_link(client, user_session):
-    workspace = WorkspaceFactory.create()
-    user_session(workspace.owner)
-    response = client.get("/workspaces/{}/applications".format(workspace.id))
+    portfolio = PortfolioFactory.create()
+    user_session(portfolio.owner)
+    response = client.get("/portfolios/{}/applications".format(portfolio.id))
     assert (
-        'href="/workspaces/{}/reports"'.format(workspace.id).encode() in response.data
+        'href="/portfolios/{}/reports"'.format(portfolio.id).encode() in response.data
     )
 
 
 def test_user_without_permission_has_no_budget_report_link(client, user_session):
     user = UserFactory.create()
-    workspace = WorkspaceFactory.create()
-    Workspaces._create_workspace_role(
-        user, workspace, "developer", status=WorkspaceRoleStatus.ACTIVE
+    portfolio = PortfolioFactory.create()
+    Portfolios._create_portfolio_role(
+        user, portfolio, "developer", status=PortfolioRoleStatus.ACTIVE
     )
     user_session(user)
-    response = client.get("/workspaces/{}/applications".format(workspace.id))
+    response = client.get("/portfolios/{}/applications".format(portfolio.id))
     assert (
-        'href="/workspaces/{}/reports"'.format(workspace.id).encode()
+        'href="/portfolios/{}/reports"'.format(portfolio.id).encode()
         not in response.data
     )
 
 
 def test_user_with_permission_has_activity_log_link(client, user_session):
-    workspace = WorkspaceFactory.create()
+    portfolio = PortfolioFactory.create()
     ccpo = UserFactory.from_atat_role("ccpo")
     admin = UserFactory.create()
-    WorkspaceRoleFactory.create(
-        workspace=workspace,
+    PortfolioRoleFactory.create(
+        portfolio=portfolio,
         user=admin,
         role=Roles.get("admin"),
-        status=WorkspaceRoleStatus.ACTIVE,
+        status=PortfolioRoleStatus.ACTIVE,
     )
 
-    user_session(workspace.owner)
-    response = client.get("/workspaces/{}/applications".format(workspace.id))
+    user_session(portfolio.owner)
+    response = client.get("/portfolios/{}/applications".format(portfolio.id))
     assert (
-        'href="/workspaces/{}/activity"'.format(workspace.id).encode() in response.data
+        'href="/portfolios/{}/activity"'.format(portfolio.id).encode() in response.data
     )
 
     # logs out previous user before creating a new session
     user_session(admin)
-    response = client.get("/workspaces/{}/applications".format(workspace.id))
+    response = client.get("/portfolios/{}/applications".format(portfolio.id))
     assert (
-        'href="/workspaces/{}/activity"'.format(workspace.id).encode() in response.data
+        'href="/portfolios/{}/activity"'.format(portfolio.id).encode() in response.data
     )
 
     user_session(ccpo)
-    response = client.get("/workspaces/{}/applications".format(workspace.id))
+    response = client.get("/portfolios/{}/applications".format(portfolio.id))
     assert (
-        'href="/workspaces/{}/activity"'.format(workspace.id).encode() in response.data
+        'href="/portfolios/{}/activity"'.format(portfolio.id).encode() in response.data
     )
 
 
 def test_user_without_permission_has_no_activity_log_link(client, user_session):
-    workspace = WorkspaceFactory.create()
+    portfolio = PortfolioFactory.create()
     developer = UserFactory.create()
-    WorkspaceRoleFactory.create(
-        workspace=workspace,
+    PortfolioRoleFactory.create(
+        portfolio=portfolio,
         user=developer,
         role=Roles.get("developer"),
-        status=WorkspaceRoleStatus.ACTIVE,
+        status=PortfolioRoleStatus.ACTIVE,
     )
 
     user_session(developer)
-    response = client.get("/workspaces/{}/applications".format(workspace.id))
+    response = client.get("/portfolios/{}/applications".format(portfolio.id))
     assert (
-        'href="/workspaces/{}/activity"'.format(workspace.id).encode()
+        'href="/portfolios/{}/activity"'.format(portfolio.id).encode()
         not in response.data
     )
 
 
 def test_user_with_permission_has_add_application_link(client, user_session):
-    workspace = WorkspaceFactory.create()
-    user_session(workspace.owner)
-    response = client.get("/workspaces/{}/applications".format(workspace.id))
+    portfolio = PortfolioFactory.create()
+    user_session(portfolio.owner)
+    response = client.get("/portfolios/{}/applications".format(portfolio.id))
     assert (
-        'href="/workspaces/{}/applications/new"'.format(workspace.id).encode()
+        'href="/portfolios/{}/applications/new"'.format(portfolio.id).encode()
         in response.data
     )
 
 
 def test_user_without_permission_has_no_add_application_link(client, user_session):
     user = UserFactory.create()
-    workspace = WorkspaceFactory.create()
-    Workspaces._create_workspace_role(user, workspace, "developer")
+    portfolio = PortfolioFactory.create()
+    Portfolios._create_portfolio_role(user, portfolio, "developer")
     user_session(user)
-    response = client.get("/workspaces/{}/applications".format(workspace.id))
+    response = client.get("/portfolios/{}/applications".format(portfolio.id))
     assert (
-        'href="/workspaces/{}/applications/new"'.format(workspace.id).encode()
+        'href="/portfolios/{}/applications/new"'.format(portfolio.id).encode()
         not in response.data
     )
 
 
 def test_view_edit_application(client, user_session):
-    workspace = WorkspaceFactory.create()
+    portfolio = PortfolioFactory.create()
     application = Applications.create(
-        workspace.owner,
-        workspace,
+        portfolio.owner,
+        portfolio,
         "Snazzy Application",
         "A new application for me and my friends",
         {"env1", "env2"},
     )
-    user_session(workspace.owner)
+    user_session(portfolio.owner)
     response = client.get(
-        "/workspaces/{}/applications/{}/edit".format(workspace.id, application.id)
+        "/portfolios/{}/applications/{}/edit".format(portfolio.id, application.id)
     )
     assert response.status_code == 200
 
 
 def test_user_with_permission_can_update_application(client, user_session):
     owner = UserFactory.create()
-    workspace = WorkspaceFactory.create(
+    portfolio = PortfolioFactory.create(
         owner=owner,
         applications=[
             {
@@ -137,12 +137,12 @@ def test_user_with_permission_can_update_application(client, user_session):
             }
         ],
     )
-    application = workspace.applications[0]
+    application = portfolio.applications[0]
     user_session(owner)
     response = client.post(
         url_for(
-            "workspaces.update_application",
-            workspace_id=workspace.id,
+            "portfolios.update_application",
+            portfolio_id=portfolio.id,
             application_id=application.id,
         ),
         data={
@@ -160,7 +160,7 @@ def test_user_with_permission_can_update_application(client, user_session):
 def test_user_without_permission_cannot_update_application(client, user_session):
     dev = UserFactory.create()
     owner = UserFactory.create()
-    workspace = WorkspaceFactory.create(
+    portfolio = PortfolioFactory.create(
         owner=owner,
         members=[{"user": dev, "role_name": "developer"}],
         applications=[
@@ -171,12 +171,12 @@ def test_user_without_permission_cannot_update_application(client, user_session)
             }
         ],
     )
-    application = workspace.applications[0]
+    application = portfolio.applications[0]
     user_session(dev)
     response = client.post(
         url_for(
-            "workspaces.update_application",
-            workspace_id=workspace.id,
+            "portfolios.update_application",
+            portfolio_id=portfolio.id,
             application_id=application.id,
         ),
         data={"name": "New Name", "description": "A new description."},
@@ -189,9 +189,9 @@ def test_user_without_permission_cannot_update_application(client, user_session)
 
 
 def create_environment(user):
-    workspace = WorkspaceFactory.create()
-    workspace_role = WorkspaceRoleFactory.create(workspace=workspace, user=user)
-    application = ApplicationFactory.create(workspace=workspace)
+    portfolio = PortfolioFactory.create()
+    portfolio_role = PortfolioRoleFactory.create(portfolio=portfolio, user=user)
+    application = ApplicationFactory.create(portfolio=portfolio)
     return EnvironmentFactory.create(application=application, name="new environment!")
 
 
@@ -204,8 +204,8 @@ def test_environment_access_with_env_role(client, user_session):
     user_session(user)
     response = client.get(
         url_for(
-            "workspaces.access_environment",
-            workspace_id=environment.workspace.id,
+            "portfolios.access_environment",
+            portfolio_id=environment.portfolio.id,
             environment_id=environment.id,
         )
     )
@@ -219,8 +219,8 @@ def test_environment_access_with_no_role(client, user_session):
     user_session(user)
     response = client.get(
         url_for(
-            "workspaces.access_environment",
-            workspace_id=environment.workspace.id,
+            "portfolios.access_environment",
+            portfolio_id=environment.portfolio.id,
             environment_id=environment.id,
         )
     )

tests/routes/portfolios/test_invitations.py

@@ -3,51 +3,51 @@ from flask import url_for
 
 from tests.factories import (
     UserFactory,
-    WorkspaceFactory,
-    WorkspaceRoleFactory,
+    PortfolioFactory,
+    PortfolioRoleFactory,
     InvitationFactory,
     TaskOrderFactory,
 )
-from atst.domain.workspaces import Workspaces
-from atst.models.workspace_role import Status as WorkspaceRoleStatus
+from atst.domain.portfolios import Portfolios
+from atst.models.portfolio_role import Status as PortfolioRoleStatus
 from atst.models.invitation import Status as InvitationStatus
 from atst.domain.users import Users
 
 
 def test_existing_member_accepts_valid_invite(client, user_session):
-    workspace = WorkspaceFactory.create()
+    portfolio = PortfolioFactory.create()
     user = UserFactory.create()
-    ws_role = WorkspaceRoleFactory.create(
-        workspace=workspace, user=user, status=WorkspaceRoleStatus.PENDING
+    ws_role = PortfolioRoleFactory.create(
+        portfolio=portfolio, user=user, status=PortfolioRoleStatus.PENDING
     )
-    invite = InvitationFactory.create(user_id=user.id, workspace_role=ws_role)
+    invite = InvitationFactory.create(user_id=user.id, portfolio_role=ws_role)
 
-    # the user does not have access to the workspace before accepting the invite
-    assert len(Workspaces.for_user(user)) == 0
+    # the user does not have access to the portfolio before accepting the invite
+    assert len(Portfolios.for_user(user)) == 0
 
     user_session(user)
-    response = client.get(url_for("workspaces.accept_invitation", token=invite.token))
+    response = client.get(url_for("portfolios.accept_invitation", token=invite.token))
 
-    # user is redirected to the workspace view
+    # user is redirected to the portfolio view
     assert response.status_code == 302
     assert (
-        url_for("workspaces.show_workspace", workspace_id=invite.workspace.id)
+        url_for("portfolios.show_portfolio", portfolio_id=invite.portfolio.id)
         in response.headers["Location"]
     )
     # the one-time use invite is no longer usable
     assert invite.is_accepted
-    # the user has access to the workspace
-    assert len(Workspaces.for_user(user)) == 1
+    # the user has access to the portfolio
+    assert len(Portfolios.for_user(user)) == 1
 
 
 def test_new_member_accepts_valid_invite(monkeypatch, client, user_session):
-    workspace = WorkspaceFactory.create()
+    portfolio = PortfolioFactory.create()
     user_info = UserFactory.dictionary()
 
-    user_session(workspace.owner)
+    user_session(portfolio.owner)
     client.post(
-        url_for("workspaces.create_member", workspace_id=workspace.id),
-        data={"workspace_role": "developer", **user_info},
+        url_for("portfolios.create_member", portfolio_id=portfolio.id),
+        data={"portfolio_role": "developer", **user_info},
     )
 
     user = Users.get_by_dod_id(user_info["dod_id"])
@@ -57,101 +57,101 @@ def test_new_member_accepts_valid_invite(monkeypatch, client, user_session):
         "atst.domain.auth.should_redirect_to_user_profile", lambda *args: False
     )
     user_session(user)
-    response = client.get(url_for("workspaces.accept_invitation", token=token))
+    response = client.get(url_for("portfolios.accept_invitation", token=token))
 
-    # user is redirected to the workspace view
+    # user is redirected to the portfolio view
     assert response.status_code == 302
     assert (
-        url_for("workspaces.show_workspace", workspace_id=workspace.id)
+        url_for("portfolios.show_portfolio", portfolio_id=portfolio.id)
         in response.headers["Location"]
     )
-    # the user has access to the workspace
-    assert len(Workspaces.for_user(user)) == 1
+    # the user has access to the portfolio
+    assert len(Portfolios.for_user(user)) == 1
 
 
 def test_member_accepts_invalid_invite(client, user_session):
-    workspace = WorkspaceFactory.create()
+    portfolio = PortfolioFactory.create()
     user = UserFactory.create()
-    ws_role = WorkspaceRoleFactory.create(
-        user=user, workspace=workspace, status=WorkspaceRoleStatus.PENDING
+    ws_role = PortfolioRoleFactory.create(
+        user=user, portfolio=portfolio, status=PortfolioRoleStatus.PENDING
     )
     invite = InvitationFactory.create(
         user_id=user.id,
-        workspace_role=ws_role,
+        portfolio_role=ws_role,
         status=InvitationStatus.REJECTED_WRONG_USER,
     )
     user_session(user)
-    response = client.get(url_for("workspaces.accept_invitation", token=invite.token))
+    response = client.get(url_for("portfolios.accept_invitation", token=invite.token))
 
     assert response.status_code == 404
 
 
-def test_user_who_has_not_accepted_workspace_invite_cannot_view(client, user_session):
+def test_user_who_has_not_accepted_portfolio_invite_cannot_view(client, user_session):
     user = UserFactory.create()
-    workspace = WorkspaceFactory.create()
+    portfolio = PortfolioFactory.create()
 
-    # create user in workspace with invitation
-    user_session(workspace.owner)
+    # create user in portfolio with invitation
+    user_session(portfolio.owner)
     response = client.post(
-        url_for("workspaces.create_member", workspace_id=workspace.id),
-        data={"workspace_role": "developer", **user.to_dictionary()},
+        url_for("portfolios.create_member", portfolio_id=portfolio.id),
+        data={"portfolio_role": "developer", **user.to_dictionary()},
     )
 
-    # user tries to view workspace before accepting invitation
+    # user tries to view portfolio before accepting invitation
     user_session(user)
-    response = client.get("/workspaces/{}/applications".format(workspace.id))
+    response = client.get("/portfolios/{}/applications".format(portfolio.id))
     assert response.status_code == 404
 
 
 def test_user_accepts_invite_with_wrong_dod_id(client, user_session):
-    workspace = WorkspaceFactory.create()
+    portfolio = PortfolioFactory.create()
     user = UserFactory.create()
     different_user = UserFactory.create()
-    ws_role = WorkspaceRoleFactory.create(
-        user=user, workspace=workspace, status=WorkspaceRoleStatus.PENDING
+    ws_role = PortfolioRoleFactory.create(
+        user=user, portfolio=portfolio, status=PortfolioRoleStatus.PENDING
     )
-    invite = InvitationFactory.create(user_id=user.id, workspace_role=ws_role)
+    invite = InvitationFactory.create(user_id=user.id, portfolio_role=ws_role)
     user_session(different_user)
-    response = client.get(url_for("workspaces.accept_invitation", token=invite.token))
+    response = client.get(url_for("portfolios.accept_invitation", token=invite.token))
 
     assert response.status_code == 404
 
 
 def test_user_accepts_expired_invite(client, user_session):
-    workspace = WorkspaceFactory.create()
+    portfolio = PortfolioFactory.create()
     user = UserFactory.create()
-    ws_role = WorkspaceRoleFactory.create(
-        user=user, workspace=workspace, status=WorkspaceRoleStatus.PENDING
+    ws_role = PortfolioRoleFactory.create(
+        user=user, portfolio=portfolio, status=PortfolioRoleStatus.PENDING
     )
     invite = InvitationFactory.create(
         user_id=user.id,
-        workspace_role=ws_role,
+        portfolio_role=ws_role,
         status=InvitationStatus.REJECTED_EXPIRED,
         expiration_time=datetime.datetime.now() - datetime.timedelta(seconds=1),
     )
     user_session(user)
-    response = client.get(url_for("workspaces.accept_invitation", token=invite.token))
+    response = client.get(url_for("portfolios.accept_invitation", token=invite.token))
 
     assert response.status_code == 404
 
 
 def test_revoke_invitation(client, user_session):
-    workspace = WorkspaceFactory.create()
+    portfolio = PortfolioFactory.create()
     user = UserFactory.create()
-    ws_role = WorkspaceRoleFactory.create(
-        user=user, workspace=workspace, status=WorkspaceRoleStatus.PENDING
+    ws_role = PortfolioRoleFactory.create(
+        user=user, portfolio=portfolio, status=PortfolioRoleStatus.PENDING
     )
     invite = InvitationFactory.create(
         user_id=user.id,
-        workspace_role=ws_role,
+        portfolio_role=ws_role,
         status=InvitationStatus.REJECTED_EXPIRED,
         expiration_time=datetime.datetime.now() - datetime.timedelta(seconds=1),
     )
-    user_session(workspace.owner)
+    user_session(portfolio.owner)
     response = client.post(
         url_for(
-            "workspaces.revoke_invitation",
-            workspace_id=workspace.id,
+            "portfolios.revoke_invitation",
+            portfolio_id=portfolio.id,
             token=invite.token,
         )
     )
@@ -162,18 +162,18 @@ def test_revoke_invitation(client, user_session):
 
 def test_resend_invitation_sends_email(client, user_session, queue):
     user = UserFactory.create()
-    workspace = WorkspaceFactory.create()
-    ws_role = WorkspaceRoleFactory.create(
-        user=user, workspace=workspace, status=WorkspaceRoleStatus.PENDING
+    portfolio = PortfolioFactory.create()
+    ws_role = PortfolioRoleFactory.create(
+        user=user, portfolio=portfolio, status=PortfolioRoleStatus.PENDING
     )
     invite = InvitationFactory.create(
-        user_id=user.id, workspace_role=ws_role, status=InvitationStatus.PENDING
+        user_id=user.id, portfolio_role=ws_role, status=InvitationStatus.PENDING
     )
-    user_session(workspace.owner)
+    user_session(portfolio.owner)
     client.post(
         url_for(
-            "workspaces.resend_invitation",
-            workspace_id=workspace.id,
+            "portfolios.resend_invitation",
+            portfolio_id=portfolio.id,
             token=invite.token,
         )
     )
@@ -184,22 +184,22 @@ def test_resend_invitation_sends_email(client, user_session, queue):
 def test_existing_member_invite_resent_to_email_submitted_in_form(
     client, user_session, queue
 ):
-    workspace = WorkspaceFactory.create()
+    portfolio = PortfolioFactory.create()
     user = UserFactory.create()
-    ws_role = WorkspaceRoleFactory.create(
-        user=user, workspace=workspace, status=WorkspaceRoleStatus.PENDING
+    ws_role = PortfolioRoleFactory.create(
+        user=user, portfolio=portfolio, status=PortfolioRoleStatus.PENDING
     )
     invite = InvitationFactory.create(
         user_id=user.id,
-        workspace_role=ws_role,
+        portfolio_role=ws_role,
         status=InvitationStatus.PENDING,
         email="example@example.com",
     )
-    user_session(workspace.owner)
+    user_session(portfolio.owner)
     client.post(
         url_for(
-            "workspaces.resend_invitation",
-            workspace_id=workspace.id,
+            "portfolios.resend_invitation",
+            portfolio_id=portfolio.id,
             token=invite.token,
         )
     )
@@ -211,16 +211,16 @@ def test_existing_member_invite_resent_to_email_submitted_in_form(
 
 
 def test_task_order_officer_accepts_invite(monkeypatch, client, user_session):
-    workspace = WorkspaceFactory.create()
-    task_order = TaskOrderFactory.create(workspace=workspace)
+    portfolio = PortfolioFactory.create()
+    task_order = TaskOrderFactory.create(portfolio=portfolio)
     user_info = UserFactory.dictionary()
 
     # create contracting officer
-    user_session(workspace.owner)
+    user_session(portfolio.owner)
     client.post(
         url_for("task_orders.new", screen=3, task_order_id=task_order.id),
         data={
-            "workspace_role": "contracting_officer",
+            "portfolio_role": "contracting_officer",
             "ko_first_name": user_info["first_name"],
             "ko_last_name": user_info["last_name"],
             "ko_email": user_info["email"],
@@ -241,7 +241,7 @@ def test_task_order_officer_accepts_invite(monkeypatch, client, user_session):
         "atst.domain.auth.should_redirect_to_user_profile", lambda *args: False
     )
     user_session(user)
-    response = client.get(url_for("workspaces.accept_invitation", token=token))
+    response = client.get(url_for("portfolios.accept_invitation", token=token))
 
     # user is redirected to the task order review page
     assert response.status_code == 302

tests/routes/portfolios/test_members.py

@@ -2,121 +2,121 @@ from flask import url_for
 
 from tests.factories import (
     UserFactory,
-    WorkspaceFactory,
-    WorkspaceRoleFactory,
+    PortfolioFactory,
+    PortfolioRoleFactory,
     InvitationFactory,
 )
-from atst.domain.workspaces import Workspaces
-from atst.domain.workspace_roles import WorkspaceRoles
+from atst.domain.portfolios import Portfolios
+from atst.domain.portfolio_roles import PortfolioRoles
 from atst.domain.applications import Applications
 from atst.domain.environments import Environments
 from atst.domain.environment_roles import EnvironmentRoles
 from atst.queue import queue
-from atst.models.workspace_role import Status as WorkspaceRoleStatus
+from atst.models.portfolio_role import Status as PortfolioRoleStatus
 from atst.models.invitation import Status as InvitationStatus
 
 
-def create_workspace_and_invite_user(
+def create_portfolio_and_invite_user(
     ws_role="developer",
-    ws_status=WorkspaceRoleStatus.PENDING,
+    ws_status=PortfolioRoleStatus.PENDING,
     invite_status=InvitationStatus.PENDING,
 ):
-    workspace = WorkspaceFactory.create()
+    portfolio = PortfolioFactory.create()
     if ws_role != "owner":
         user = UserFactory.create()
-        member = WorkspaceRoleFactory.create(
-            user=user, workspace=workspace, status=ws_status
+        member = PortfolioRoleFactory.create(
+            user=user, portfolio=portfolio, status=ws_status
         )
         InvitationFactory.create(
-            user=workspace.owner,
-            workspace_role=member,
+            user=portfolio.owner,
+            portfolio_role=member,
             email=member.user.email,
             status=invite_status,
         )
-    return workspace
+    return portfolio
 
 
 def test_user_with_permission_has_add_member_link(client, user_session):
-    workspace = WorkspaceFactory.create()
-    user_session(workspace.owner)
-    response = client.get("/workspaces/{}/members".format(workspace.id))
+    portfolio = PortfolioFactory.create()
+    user_session(portfolio.owner)
+    response = client.get("/portfolios/{}/members".format(portfolio.id))
     assert (
-        'href="/workspaces/{}/members/new"'.format(workspace.id).encode()
+        'href="/portfolios/{}/members/new"'.format(portfolio.id).encode()
         in response.data
     )
 
 
 def test_user_without_permission_has_no_add_member_link(client, user_session):
     user = UserFactory.create()
-    workspace = WorkspaceFactory.create()
-    Workspaces._create_workspace_role(user, workspace, "developer")
+    portfolio = PortfolioFactory.create()
+    Portfolios._create_portfolio_role(user, portfolio, "developer")
     user_session(user)
-    response = client.get("/workspaces/{}/members".format(workspace.id))
+    response = client.get("/portfolios/{}/members".format(portfolio.id))
     assert (
-        'href="/workspaces/{}/members/new"'.format(workspace.id).encode()
+        'href="/portfolios/{}/members/new"'.format(portfolio.id).encode()
         not in response.data
     )
 
 
 def test_permissions_for_view_member(client, user_session):
     user = UserFactory.create()
-    workspace = WorkspaceFactory.create()
-    Workspaces._create_workspace_role(user, workspace, "developer")
-    member = WorkspaceRoles.add(user, workspace.id, "developer")
+    portfolio = PortfolioFactory.create()
+    Portfolios._create_portfolio_role(user, portfolio, "developer")
+    member = PortfolioRoles.add(user, portfolio.id, "developer")
     user_session(user)
     response = client.get(
-        url_for("workspaces.view_member", workspace_id=workspace.id, member_id=user.id)
+        url_for("portfolios.view_member", portfolio_id=portfolio.id, member_id=user.id)
     )
     assert response.status_code == 404
 
 
 def test_create_member(client, user_session):
     user = UserFactory.create()
-    workspace = WorkspaceFactory.create()
-    user_session(workspace.owner)
+    portfolio = PortfolioFactory.create()
+    user_session(portfolio.owner)
     queue_length = len(queue.get_queue())
 
     response = client.post(
-        url_for("workspaces.create_member", workspace_id=workspace.id),
+        url_for("portfolios.create_member", portfolio_id=portfolio.id),
         data={
             "dod_id": user.dod_id,
             "first_name": "Wilbur",
             "last_name": "Zuckerman",
             "email": "some_pig@zuckermans.com",
-            "workspace_role": "developer",
+            "portfolio_role": "developer",
         },
         follow_redirects=True,
     )
 
     assert response.status_code == 200
-    assert user.has_workspaces
+    assert user.has_portfolios
     assert user.invitations
     assert len(queue.get_queue()) == queue_length + 1
 
 
 def test_view_member_shows_role(client, user_session):
     user = UserFactory.create()
-    workspace = WorkspaceFactory.create()
-    Workspaces._create_workspace_role(user, workspace, "developer")
-    member = WorkspaceRoles.add(user, workspace.id, "developer")
-    user_session(workspace.owner)
+    portfolio = PortfolioFactory.create()
+    Portfolios._create_portfolio_role(user, portfolio, "developer")
+    member = PortfolioRoles.add(user, portfolio.id, "developer")
+    user_session(portfolio.owner)
     response = client.get(
-        url_for("workspaces.view_member", workspace_id=workspace.id, member_id=user.id)
+        url_for("portfolios.view_member", portfolio_id=portfolio.id, member_id=user.id)
     )
     assert response.status_code == 200
     assert "initial-choice='developer'".encode() in response.data
 
 
-def test_update_member_workspace_role(client, user_session):
-    workspace = WorkspaceFactory.create()
+def test_update_member_portfolio_role(client, user_session):
+    portfolio = PortfolioFactory.create()
     user = UserFactory.create()
-    member = WorkspaceRoles.add(user, workspace.id, "developer")
-    user_session(workspace.owner)
+    member = PortfolioRoles.add(user, portfolio.id, "developer")
+    user_session(portfolio.owner)
     response = client.post(
         url_for(
-            "workspaces.update_member", workspace_id=workspace.id, member_id=user.id
+            "portfolios.update_member", portfolio_id=portfolio.id, member_id=user.id
         ),
-        data={"workspace_role": "security_auditor"},
+        data={"portfolio_role": "security_auditor"},
         follow_redirects=True,
     )
     assert response.status_code == 200
@@ -124,14 +124,14 @@ def test_update_member_workspace_role(client, user_session):
     assert member.role_name == "security_auditor"
 
 
-def test_update_member_workspace_role_with_no_data(client, user_session):
-    workspace = WorkspaceFactory.create()
+def test_update_member_portfolio_role_with_no_data(client, user_session):
+    portfolio = PortfolioFactory.create()
     user = UserFactory.create()
-    member = WorkspaceRoles.add(user, workspace.id, "developer")
-    user_session(workspace.owner)
+    member = PortfolioRoles.add(user, portfolio.id, "developer")
+    user_session(portfolio.owner)
     response = client.post(
         url_for(
-            "workspaces.update_member", workspace_id=workspace.id, member_id=user.id
+            "portfolios.update_member", portfolio_id=portfolio.id, member_id=user.id
         ),
         data={},
         follow_redirects=True,
@@ -141,12 +141,12 @@ def test_update_member_workspace_role_with_no_data(client, user_session):
 
 
 def test_update_member_environment_role(client, user_session):
-    workspace = WorkspaceFactory.create()
+    portfolio = PortfolioFactory.create()
     user = UserFactory.create()
-    member = WorkspaceRoles.add(user, workspace.id, "developer")
+    member = PortfolioRoles.add(user, portfolio.id, "developer")
     application = Applications.create(
-        workspace.owner,
-        workspace,
+        portfolio.owner,
+        portfolio,
         "Snazzy Application",
         "A new application for me and my friends",
         {"env1", "env2"},
@@ -155,13 +155,13 @@ def test_update_member_environment_role(client, user_session):
     env2_id = application.environments[1].id
     for env in application.environments:
         Environments.add_member(env, user, "developer")
-    user_session(workspace.owner)
+    user_session(portfolio.owner)
     response = client.post(
         url_for(
-            "workspaces.update_member", workspace_id=workspace.id, member_id=user.id
+            "portfolios.update_member", portfolio_id=portfolio.id, member_id=user.id
         ),
         data={
-            "workspace_role": "developer",
+            "portfolio_role": "developer",
             "env_" + str(env1_id): "security_auditor",
             "env_" + str(env2_id): "devops",
         },
@@ -175,12 +175,12 @@ def test_update_member_environment_role(client, user_session):
 
 
 def test_update_member_environment_role_with_no_data(client, user_session):
-    workspace = WorkspaceFactory.create()
+    portfolio = PortfolioFactory.create()
     user = UserFactory.create()
-    member = WorkspaceRoles.add(user, workspace.id, "developer")
+    member = PortfolioRoles.add(user, portfolio.id, "developer")
     application = Applications.create(
-        workspace.owner,
-        workspace,
+        portfolio.owner,
+        portfolio,
         "Snazzy Application",
         "A new application for me and my friends",
         {"env1"},
@@ -188,10 +188,10 @@ def test_update_member_environment_role_with_no_data(client, user_session):
     env1_id = application.environments[0].id
     for env in application.environments:
         Environments.add_member(env, user, "developer")
-    user_session(workspace.owner)
+    user_session(portfolio.owner)
     response = client.post(
         url_for(
-            "workspaces.update_member", workspace_id=workspace.id, member_id=user.id
+            "portfolios.update_member", portfolio_id=portfolio.id, member_id=user.id
         ),
         data={"env_" + str(env1_id): None, "env_" + str(env1_id): ""},
         follow_redirects=True,
@@ -202,36 +202,36 @@ def test_update_member_environment_role_with_no_data(client, user_session):
 
 
 def test_revoke_active_member_access(client, user_session):
-    workspace = WorkspaceFactory.create()
+    portfolio = PortfolioFactory.create()
     user = UserFactory.create()
-    member = WorkspaceRoleFactory.create(
-        workspace=workspace, user=user, status=WorkspaceRoleStatus.ACTIVE
+    member = PortfolioRoleFactory.create(
+        portfolio=portfolio, user=user, status=PortfolioRoleStatus.ACTIVE
     )
     Applications.create(
-        workspace.owner,
-        workspace,
+        portfolio.owner,
+        portfolio,
         "Snazzy Application",
         "A new application for me and my friends",
         {"env1"},
     )
-    user_session(workspace.owner)
+    user_session(portfolio.owner)
     response = client.post(
         url_for(
-            "workspaces.revoke_access", workspace_id=workspace.id, member_id=member.id
+            "portfolios.revoke_access", portfolio_id=portfolio.id, member_id=member.id
         )
     )
     assert response.status_code == 302
-    assert WorkspaceRoles.get_by_id(member.id).num_environment_roles == 0
+    assert PortfolioRoles.get_by_id(member.id).num_environment_roles == 0
 
 
 def test_does_not_show_any_buttons_if_owner(client, user_session):
-    workspace = WorkspaceFactory.create()
-    user_session(workspace.owner)
+    portfolio = PortfolioFactory.create()
+    user_session(portfolio.owner)
     response = client.get(
         url_for(
-            "workspaces.view_member",
-            workspace_id=workspace.id,
-            member_id=workspace.owner.id,
+            "portfolios.view_member",
+            portfolio_id=portfolio.id,
+            member_id=portfolio.owner.id,
         )
     )
     assert "Remove Portfolio Access" not in response.data.decode()
@@ -240,15 +240,15 @@ def test_does_not_show_any_buttons_if_owner(client, user_session):
 
 
 def test_only_shows_revoke_access_button_if_active(client, user_session):
-    workspace = create_workspace_and_invite_user(
-        ws_status=WorkspaceRoleStatus.ACTIVE, invite_status=InvitationStatus.ACCEPTED
+    portfolio = create_portfolio_and_invite_user(
+        ws_status=PortfolioRoleStatus.ACTIVE, invite_status=InvitationStatus.ACCEPTED
     )
-    user_session(workspace.owner)
-    member = workspace.members[1]
+    user_session(portfolio.owner)
+    member = portfolio.members[1]
     response = client.get(
         url_for(
-            "workspaces.view_member",
-            workspace_id=workspace.id,
+            "portfolios.view_member",
+            portfolio_id=portfolio.id,
             member_id=member.user.id,
         )
     )
@@ -258,15 +258,15 @@ def test_only_shows_revoke_access_button_if_active(client, user_session):
 
 
 def test_only_shows_revoke_invite_button_if_pending(client, user_session):
-    workspace = create_workspace_and_invite_user(
-        ws_status=WorkspaceRoleStatus.PENDING, invite_status=InvitationStatus.PENDING
+    portfolio = create_portfolio_and_invite_user(
+        ws_status=PortfolioRoleStatus.PENDING, invite_status=InvitationStatus.PENDING
     )
-    user_session(workspace.owner)
-    member = workspace.members[1]
+    user_session(portfolio.owner)
+    member = portfolio.members[1]
     response = client.get(
         url_for(
-            "workspaces.view_member",
-            workspace_id=workspace.id,
+            "portfolios.view_member",
+            portfolio_id=portfolio.id,
             member_id=member.user.id,
         )
     )
@@ -276,16 +276,16 @@ def test_only_shows_revoke_invite_button_if_pending(client, user_session):
 
 
 def test_only_shows_resend_button_if_expired(client, user_session):
-    workspace = create_workspace_and_invite_user(
-        ws_status=WorkspaceRoleStatus.PENDING,
+    portfolio = create_portfolio_and_invite_user(
+        ws_status=PortfolioRoleStatus.PENDING,
         invite_status=InvitationStatus.REJECTED_EXPIRED,
     )
-    user_session(workspace.owner)
-    member = workspace.members[1]
+    user_session(portfolio.owner)
+    member = portfolio.members[1]
     response = client.get(
         url_for(
-            "workspaces.view_member",
-            workspace_id=workspace.id,
+            "portfolios.view_member",
+            portfolio_id=portfolio.id,
             member_id=member.user.id,
         )
     )
@@ -295,15 +295,15 @@ def test_only_shows_resend_button_if_expired(client, user_session):
 
 
 def test_only_shows_resend_button_if_revoked(client, user_session):
-    workspace = create_workspace_and_invite_user(
-        ws_status=WorkspaceRoleStatus.PENDING, invite_status=InvitationStatus.REVOKED
+    portfolio = create_portfolio_and_invite_user(
+        ws_status=PortfolioRoleStatus.PENDING, invite_status=InvitationStatus.REVOKED
     )
-    user_session(workspace.owner)
-    member = workspace.members[1]
+    user_session(portfolio.owner)
+    member = portfolio.members[1]
     response = client.get(
         url_for(
-            "workspaces.view_member",
-            workspace_id=workspace.id,
+            "portfolios.view_member",
+            portfolio_id=portfolio.id,
             member_id=member.user.id,
         )
     )

tests/routes/portfolios/test_portfolios_index.py

@@ -0,0 +1,15 @@
+from flask import url_for
+
+from tests.factories import PortfolioFactory
+
+
+def test_update_portfolio_name(client, user_session):
+    portfolio = PortfolioFactory.create()
+    user_session(portfolio.owner)
+    response = client.post(
+        url_for("portfolios.edit_portfolio", portfolio_id=portfolio.id),
+        data={"name": "a cool new name"},
+        follow_redirects=True,
+    )
+    assert response.status_code == 200
+    assert portfolio.name == "a cool new name"

tests/routes/requests/test_requests_index.py

@@ -9,7 +9,7 @@ def test_action_required_mission_owner():
     creator = UserFactory.create()
     requests = RequestFactory.create_batch(5, creator=creator)
     Requests.submit(requests[0])
-    Requests.approve_and_create_workspace(requests[1])
+    Requests.approve_and_create_portfolio(requests[1])
 
     context = RequestsIndex(creator).execute()
 
@@ -20,7 +20,7 @@ def test_action_required_ccpo():
     creator = UserFactory.create()
     requests = RequestFactory.create_batch(5, creator=creator)
     Requests.submit(requests[0])
-    Requests.approve_and_create_workspace(requests[1])
+    Requests.approve_and_create_portfolio(requests[1])
 
     ccpo = UserFactory.from_atat_role("ccpo")
     context = RequestsIndex(ccpo).execute()

tests/routes/task_orders/test_index.py

@@ -5,7 +5,7 @@ from zipfile import ZipFile
 
 from atst.utils.docx import Docx
 
-from tests.factories import TaskOrderFactory, WorkspaceFactory, UserFactory
+from tests.factories import TaskOrderFactory, PortfolioFactory, UserFactory
 
 
 def xml_translated(val):
@@ -16,8 +16,8 @@ def xml_translated(val):
 
 def test_download_summary(client, user_session):
     user = UserFactory.create()
-    workspace = WorkspaceFactory.create(owner=user)
-    task_order = TaskOrderFactory.create(creator=user, workspace=workspace)
+    portfolio = PortfolioFactory.create(owner=user)
+    task_order = TaskOrderFactory.create(creator=user, portfolio=portfolio)
     user_session(user)
     response = client.get(
         url_for("task_orders.download_summary", task_order_id=task_order.id)

tests/routes/task_orders/test_new_task_order.py

@@ -4,7 +4,7 @@ from flask import url_for
 from atst.domain.task_orders import TaskOrders
 from atst.routes.task_orders.new import ShowTaskOrderWorkflow, UpdateTaskOrderWorkflow
 
-from tests.factories import UserFactory, TaskOrderFactory, WorkspaceFactory
+from tests.factories import UserFactory, TaskOrderFactory, PortfolioFactory
 
 
 def test_new_task_order(client, user_session):
@@ -95,9 +95,9 @@ def test_task_order_form_shows_errors(client, user_session):
 @pytest.fixture
 def task_order():
     user = UserFactory.create()
-    workspace = WorkspaceFactory.create(owner=user)
+    portfolio = PortfolioFactory.create(owner=user)
 
-    return TaskOrderFactory.create(creator=user, workspace=workspace)
+    return TaskOrderFactory.create(creator=user, portfolio=portfolio)
 
 
 def test_show_task_order(task_order):
@@ -112,9 +112,9 @@ def test_show_task_order(task_order):
 def test_show_task_order_form_list_data():
     complexity = ["oconus", "tactical_edge"]
     user = UserFactory.create()
-    workspace = WorkspaceFactory.create(owner=user)
+    portfolio = PortfolioFactory.create(owner=user)
     task_order = TaskOrderFactory.create(
-        creator=user, workspace=workspace, complexity=complexity
+        creator=user, portfolio=portfolio, complexity=complexity
     )
     workflow = ShowTaskOrderWorkflow(user, task_order_id=task_order.id)
 
@@ -173,10 +173,10 @@ def test_invite_officers_to_task_order(task_order, queue):
         task_order.creator, to_data, screen=3, task_order_id=task_order.id
     )
     workflow.update()
-    workspace = task_order.workspace
-    # owner and three officers are workspace members
-    assert len(workspace.members) == 4
-    roles = [member.role.name for member in workspace.members]
+    portfolio = task_order.portfolio
+    # owner and three officers are portfolio members
+    assert len(portfolio.members) == 4
+    roles = [member.role.name for member in portfolio.members]
     # officers exist in roles
     assert roles.count("officer") == 3
     # email invitations are enqueued
@@ -198,9 +198,9 @@ def test_add_officer_but_do_not_invite(task_order, queue):
         task_order.creator, to_data, screen=3, task_order_id=task_order.id
     )
     workflow.update()
-    workspace = task_order.workspace
-    # owner is only workspace member
-    assert len(workspace.members) == 1
+    portfolio = task_order.portfolio
+    # owner is only portfolio member
+    assert len(portfolio.members) == 1
     # no invitations are enqueued
     assert len(queue.get_queue()) == 0
 
@@ -208,10 +208,10 @@ def test_add_officer_but_do_not_invite(task_order, queue):
 def test_update_does_not_resend_invitation():
     user = UserFactory.create()
     contracting_officer = UserFactory.create()
-    workspace = WorkspaceFactory.create(owner=user)
+    portfolio = PortfolioFactory.create(owner=user)
     task_order = TaskOrderFactory.create(
         creator=user,
-        workspace=workspace,
+        portfolio=portfolio,
         ko_first_name=contracting_officer.first_name,
         ko_last_name=contracting_officer.last_name,
         ko_dod_id=contracting_officer.dod_id,

tests/routes/test_auth.py

@@ -4,7 +4,7 @@ from urllib.parse import quote
 from tests.factories import UserFactory
 
 
-PROTECTED_URL = "/workspaces"
+PROTECTED_URL = "/portfolios"
 
 
 def test_request_page_with_complete_profile(client, user_session):

tests/routes/test_home.py

@@ -1,26 +1,26 @@
 import pytest
 
-from tests.factories import UserFactory, WorkspaceFactory, RequestFactory
-from atst.domain.workspaces import Workspaces
+from tests.factories import UserFactory, PortfolioFactory, RequestFactory
+from atst.domain.portfolios import Portfolios
 
 
-def test_user_with_workspaces_has_workspaces_nav(client, user_session):
-    workspace = WorkspaceFactory.create()
-    user_session(workspace.owner)
+def test_user_with_portfolios_has_portfolios_nav(client, user_session):
+    portfolio = PortfolioFactory.create()
+    user_session(portfolio.owner)
     response = client.get("/home", follow_redirects=True)
-    assert b'href="/workspaces"' in response.data
+    assert b'href="/portfolios"' in response.data
 
 
 @pytest.mark.skip(reason="this may no longer be accurate")
-def test_user_without_workspaces_has_no_workspaces_nav(client, user_session):
+def test_user_without_portfolios_has_no_portfolios_nav(client, user_session):
     user = UserFactory.create()
     user_session(user)
     response = client.get("/home", follow_redirects=True)
-    assert b'href="/workspaces"' not in response.data
+    assert b'href="/portfolios"' not in response.data
 
 
 @pytest.mark.skip(reason="this may no longer be accurate")
-def test_request_owner_with_no_workspaces_redirected_to_requests(client, user_session):
+def test_request_owner_with_no_portfolios_redirected_to_requests(client, user_session):
     request = RequestFactory.create()
     user_session(request.creator)
     response = client.get("/home", follow_redirects=False)
@@ -28,31 +28,31 @@ def test_request_owner_with_no_workspaces_redirected_to_requests(client, user_se
     assert "/requests" in response.location
 
 
-def test_request_owner_with_one_workspace_redirected_to_reports(client, user_session):
+def test_request_owner_with_one_portfolio_redirected_to_reports(client, user_session):
     request = RequestFactory.create()
-    workspace = Workspaces.create_from_request(request)
+    portfolio = Portfolios.create_from_request(request)
 
     user_session(request.creator)
     response = client.get("/home", follow_redirects=False)
 
-    assert "/workspaces/{}/reports".format(workspace.id) in response.location
+    assert "/portfolios/{}/reports".format(portfolio.id) in response.location
 
 
-def test_request_owner_with_more_than_one_workspace_redirected_to_workspaces(
+def test_request_owner_with_more_than_one_portfolio_redirected_to_portfolios(
     client, user_session
 ):
     request_creator = UserFactory.create()
-    Workspaces.create_from_request(RequestFactory.create(creator=request_creator))
-    Workspaces.create_from_request(RequestFactory.create(creator=request_creator))
+    Portfolios.create_from_request(RequestFactory.create(creator=request_creator))
+    Portfolios.create_from_request(RequestFactory.create(creator=request_creator))
 
     user_session(request_creator)
     response = client.get("/home", follow_redirects=False)
 
-    assert "/workspaces" in response.location
+    assert "/portfolios" in response.location
 
 
 @pytest.mark.skip(reason="this may no longer be accurate")
-def test_non_owner_user_with_no_workspaces_redirected_to_requests(client, user_session):
+def test_non_owner_user_with_no_portfolios_redirected_to_requests(client, user_session):
     user = UserFactory.create()
 
     user_session(user)
@@ -61,39 +61,39 @@ def test_non_owner_user_with_no_workspaces_redirected_to_requests(client, user_s
     assert "/requests" in response.location
 
 
-def test_non_owner_user_with_one_workspace_redirected_to_workspace_applications(
+def test_non_owner_user_with_one_portfolio_redirected_to_portfolio_applications(
     client, user_session
 ):
     user = UserFactory.create()
-    workspace = WorkspaceFactory.create()
-    Workspaces._create_workspace_role(user, workspace, "developer")
+    portfolio = PortfolioFactory.create()
+    Portfolios._create_portfolio_role(user, portfolio, "developer")
 
     user_session(user)
     response = client.get("/home", follow_redirects=False)
 
-    assert "/workspaces/{}/applications".format(workspace.id) in response.location
+    assert "/portfolios/{}/applications".format(portfolio.id) in response.location
 
 
-def test_non_owner_user_with_mulitple_workspaces_redirected_to_workspaces(
+def test_non_owner_user_with_mulitple_portfolios_redirected_to_portfolios(
     client, user_session
 ):
     user = UserFactory.create()
     for _ in range(3):
-        workspace = WorkspaceFactory.create()
-        Workspaces._create_workspace_role(user, workspace, "developer")
+        portfolio = PortfolioFactory.create()
+        Portfolios._create_portfolio_role(user, portfolio, "developer")
 
     user_session(user)
     response = client.get("/home", follow_redirects=False)
 
-    assert "/workspaces" in response.location
+    assert "/portfolios" in response.location
 
 
 @pytest.mark.skip(reason="this may no longer be accurate")
 def test_ccpo_user_redirected_to_requests(client, user_session):
     user = UserFactory.from_atat_role("ccpo")
     for _ in range(3):
-        workspace = WorkspaceFactory.create()
-        Workspaces._create_workspace_role(user, workspace, "developer")
+        portfolio = PortfolioFactory.create()
+        Portfolios._create_portfolio_role(user, portfolio, "developer")
 
     user_session(user)
     response = client.get("/home", follow_redirects=False)

tests/routes/workspaces/test_workspaces_index.py

@@ -1,15 +0,0 @@
-from flask import url_for
-
-from tests.factories import WorkspaceFactory
-
-
-def test_update_workspace_name(client, user_session):
-    workspace = WorkspaceFactory.create()
-    user_session(workspace.owner)
-    response = client.post(
-        url_for("workspaces.edit_workspace", workspace_id=workspace.id),
-        data={"name": "a cool new name"},
-        follow_redirects=True,
-    )
-    assert response.status_code == 200
-    assert workspace.name == "a cool new name"