Clean up workspaces tests

tests/domain/test_workspaces.py

@@ -7,20 +7,36 @@ from atst.domain.workspace_users import WorkspaceUsers
 from atst.domain.projects import Projects
 from atst.domain.environments import Environments
 
-from tests.factories import WorkspaceFactory, RequestFactory, UserFactory
+from tests.factories import RequestFactory, UserFactory
 
 
-def test_can_create_workspace():
+@pytest.fixture(scope="function")
-    request = RequestFactory.create()
+def workspace_owner():
-    workspace = Workspaces.create(request, name="frugal-whale")
+    return UserFactory.create()
+
+
+@pytest.fixture(scope="function")
+def request_(workspace_owner):
+    return RequestFactory.create(creator=workspace_owner)
+
+
+@pytest.fixture(scope="function")
+def workspace(request_):
+    workspace = Workspaces.create(request_)
+    return workspace
+
+
+def test_can_create_workspace(request_):
+    workspace = Workspaces.create(request_, name="frugal-whale")
     assert workspace.name == "frugal-whale"
-    assert workspace.request == request
 
 
-def test_default_workspace_name_is_request_id():
+def test_request_is_associated_with_workspace(workspace, request_):
-    request = RequestFactory.create()
+    assert workspace.request == request_
-    workspace = Workspaces.create(request)
+
-    assert workspace.name == str(request.id)
+
+def test_default_workspace_name_is_request_id(workspace, request_):
+    assert workspace.name == str(request_.id)
 
 
 def test_get_nonexistent_workspace_raises():
@@ -28,33 +44,21 @@ def test_get_nonexistent_workspace_raises():
         Workspaces.get(UserFactory.build(), uuid4())
 
 
-def test_can_get_workspace_by_request():
+def test_can_get_workspace_by_request(workspace):
-    workspace = WorkspaceFactory.create()
     found = Workspaces.get_by_request(workspace.request)
     assert workspace == found
 
 
-def test_creating_workspace_adds_owner():
+def test_creating_workspace_adds_owner(workspace, workspace_owner):
-    user = UserFactory.create()
+    assert workspace.roles[0].user == workspace_owner
-    request = RequestFactory.create(creator=user)
-    workspace = Workspaces.create(request)
-    assert workspace.roles[0].user == user
 
 
-def test_workspace_has_timestamps():
+def test_workspace_has_timestamps(workspace):
-    request = RequestFactory.create()
-    workspace = Workspaces.create(request)
     assert workspace.time_created == workspace.time_updated
 
 
-def test_workspaces_get_ensures_user_is_in_workspace():
+def test_workspaces_get_ensures_user_is_in_workspace(workspace, workspace_owner):
-    owner = UserFactory.create()
     outside_user = UserFactory.create()
-    workspace = Workspaces.create(RequestFactory.create(creator=owner))
-
-    workspace_ = Workspaces.get(owner, workspace.id)
-    assert workspace_ == workspace
-
     with pytest.raises(UnauthorizedError):
         Workspaces.get(outside_user, workspace.id)
 
@@ -64,37 +68,26 @@ def test_workspaces_get_many_with_no_workspaces():
     assert workspaces == []
 
 
-def test_workspaces_get_many_returns_a_users_workspaces():
+def test_workspaces_get_many_returns_a_users_workspaces(workspace, workspace_owner):
-    user = UserFactory.create()
-    users_workspace = Workspaces.create(RequestFactory.create(creator=user))
-
     # random workspace
     Workspaces.create(RequestFactory.create())
 
-    assert Workspaces.get_many(user) == [users_workspace]
+    assert Workspaces.get_many(workspace_owner) == [workspace]
 
 
-def test_get_for_update_allows_owner():
+def test_get_for_update_allows_owner(workspace, workspace_owner):
-    owner = UserFactory.create()
+    Workspaces.get_for_update(workspace_owner, workspace.id)
-    workspace = Workspaces.create(RequestFactory.create(creator=owner))
-    Workspaces.get_for_update(owner, workspace.id)
 
 
-def test_get_for_update_blocks_developer():
+def test_get_for_update_blocks_developer(workspace):
-    owner = UserFactory.create()
     developer = UserFactory.create()
-
-    workspace = Workspaces.create(RequestFactory.create(creator=owner))
     WorkspaceUsers.add(developer, workspace.id, "developer")
 
     with pytest.raises(UnauthorizedError):
         Workspaces.get_for_update(developer, workspace.id)
 
 
-def test_can_create_workspace_user():
+def test_can_create_workspace_user(workspace, workspace_owner):
-    owner = UserFactory.create()
-    workspace = Workspaces.create(RequestFactory.create(creator=owner))
-
     user_data = {
         "first_name": "New",
         "last_name": "User",
@@ -103,12 +96,11 @@ def test_can_create_workspace_user():
         "dod_id": "1234567890",
     }
 
-    new_member = Workspaces.create_member(owner, workspace, user_data)
+    new_member = Workspaces.create_member(workspace_owner, workspace, user_data)
     assert new_member.workspace == workspace
 
 
-def test_need_permission_to_create_workspace_user():
+def test_need_permission_to_create_workspace_user(workspace, workspace_owner):
-    workspace = Workspaces.create(request=RequestFactory.create())
     random_user = UserFactory.create()
 
     user_data = {
@@ -123,9 +115,7 @@ def test_need_permission_to_create_workspace_user():
         Workspaces.create_member(random_user, workspace, user_data)
 
 
-def test_update_workspace_user_role():
+def test_update_workspace_user_role(workspace, workspace_owner):
-    owner = UserFactory.create()
-    workspace = Workspaces.create(RequestFactory.create(creator=owner))
     user_data = {
         "first_name": "New",
         "last_name": "User",
@@ -133,17 +123,17 @@ def test_update_workspace_user_role():
         "workspace_role": "developer",
         "dod_id": "1234567890",
     }
-    member = Workspaces.create_member(owner, workspace, user_data)
+    member = Workspaces.create_member(workspace_owner, workspace, user_data)
     role_name = "admin"
 
-    updated_member = Workspaces.update_member(owner, workspace, member, role_name)
+    updated_member = Workspaces.update_member(
+        workspace_owner, workspace, member, role_name
+    )
     assert updated_member.workspace == workspace
     assert updated_member.role == role_name
 
 
-def test_need_permission_to_update_workspace_user_role():
+def test_need_permission_to_update_workspace_user_role(workspace, workspace_owner):
-    owner = UserFactory.create()
-    workspace = Workspaces.create(RequestFactory.create(creator=owner))
     random_user = UserFactory.create()
     user_data = {
         "first_name": "New",
@@ -152,41 +142,38 @@ def test_need_permission_to_update_workspace_user_role():
         "workspace_role": "developer",
         "dod_id": "1234567890",
     }
-    member = Workspaces.create_member(owner, workspace, user_data)
+    member = Workspaces.create_member(workspace_owner, workspace, user_data)
     role_name = "developer"
 
     with pytest.raises(UnauthorizedError):
         Workspaces.update_member(random_user, workspace, member, role_name)
 
 
-def test_owner_can_view_workspace_members():
+def test_owner_can_view_workspace_members(workspace, workspace_owner):
-    owner = UserFactory.create()
+    workspace_owner = UserFactory.create()
-    workspace = Workspaces.create(RequestFactory.create(creator=owner))
+    workspace = Workspaces.create(RequestFactory.create(creator=workspace_owner))
-    workspace = Workspaces.get_with_members(owner, workspace.id)
+    workspace = Workspaces.get_with_members(workspace_owner, workspace.id)
 
     assert workspace
 
 
-def test_ccpo_can_view_workspace_members():
+def test_ccpo_can_view_workspace_members(workspace, workspace_owner):
-    workspace = Workspaces.create(RequestFactory.create(creator=UserFactory.create()))
     ccpo = UserFactory.from_atat_role("ccpo")
-    workspace = Workspaces.get_with_members(ccpo, workspace.id)
+    assert Workspaces.get_with_members(ccpo, workspace.id)
-
-    assert workspace
 
 
-def test_random_user_cannot_view_workspace_members():
+def test_random_user_cannot_view_workspace_members(workspace):
-    workspace = Workspaces.create(RequestFactory.create(creator=UserFactory.create()))
     developer = UserFactory.from_atat_role("developer")
 
     with pytest.raises(UnauthorizedError):
         workspace = Workspaces.get_with_members(developer, workspace.id)
 
 
-def test_scoped_workspace_only_returns_a_users_projects_and_environments():
+def test_scoped_workspace_only_returns_a_users_projects_and_environments(
-    workspace = WorkspaceFactory.create()
+    workspace, workspace_owner
+):
     new_project = Projects.create(
-        workspace.owner,
+        workspace_owner,
         workspace,
         "My Project",
         "My project",
@@ -194,7 +181,7 @@ def test_scoped_workspace_only_returns_a_users_projects_and_environments():
     )
     developer = UserFactory.from_atat_role("developer")
     dev_environment = Environments.add_member(
-        workspace.owner, new_project.environments[0], developer
+        workspace_owner, new_project.environments[0], developer
     )
 
     scoped_workspace = Workspaces.get(developer, workspace.id)
@@ -205,11 +192,12 @@ def test_scoped_workspace_only_returns_a_users_projects_and_environments():
     assert scoped_workspace.projects[0].environments == [dev_environment]
 
 
-def test_scoped_workspace_returns_all_projects_for_workspace_admin():
+def test_scoped_workspace_returns_all_projects_for_workspace_admin(
-    workspace = Workspaces.create(RequestFactory.create())
+    workspace, workspace_owner
+):
     for _ in range(5):
         Projects.create(
-            workspace.owner,
+            workspace_owner,
             workspace,
             "My Project",
             "My project",
@@ -225,34 +213,35 @@ def test_scoped_workspace_returns_all_projects_for_workspace_admin():
     assert len(scoped_workspace.projects[0].environments) == 3
 
 
-def test_scoped_workspace_returns_all_projects_for_workspace_owner():
+def test_scoped_workspace_returns_all_projects_for_workspace_owner(
-    workspace = Workspaces.create(RequestFactory.create())
+    workspace, workspace_owner
-    owner = workspace.owner
+):
     for _ in range(5):
         Projects.create(
-            owner, workspace, "My Project", "My project", ["dev", "staging", "prod"]
+            workspace_owner,
+            workspace,
+            "My Project",
+            "My project",
+            ["dev", "staging", "prod"],
         )
 
-    scoped_workspace = Workspaces.get(owner, workspace.id)
+    scoped_workspace = Workspaces.get(workspace_owner, workspace.id)
 
     assert len(scoped_workspace.projects) == 5
     assert len(scoped_workspace.projects[0].environments) == 3
 
 
-def test_for_user_workspace_member():
+def test_for_user_returns_assigned_workspaces_for_user(workspace, workspace_owner):
     bob = UserFactory.from_atat_role("default")
-    workspace = Workspaces.create(RequestFactory.create())
     Workspaces.add_member(workspace, bob, "developer")
-
     Workspaces.create(RequestFactory.create())
-
     bobs_workspaces = Workspaces.for_user(bob)
+
     assert len(bobs_workspaces) == 1
 
 
-def test_for_user_ccpo():
+def test_for_user_returns_all_workspaces_for_ccpo(workspace, workspace_owner):
     sam = UserFactory.from_atat_role("ccpo")
-    workspace = Workspaces.create(RequestFactory.create())
     Workspaces.create(RequestFactory.create())
 
     sams_workspaces = Workspaces.for_user(sam)