Merge pull request #378 from dod-ccpo/refactor-tests

Refactor factories to make test setup more declarative

tests/domain/test_environments.py

@@ -1,50 +1,42 @@
-import pytest
-from uuid import uuid4
-
 from atst.domain.environments import Environments
 from atst.domain.environment_roles import EnvironmentRoles
-from atst.domain.projects import Projects
-from atst.domain.roles import Roles
-from atst.domain.workspaces import Workspaces
-from atst.domain.workspace_users import WorkspaceUsers
-from atst.domain.exceptions import NotFoundError
-from atst.models.environment_role import EnvironmentRole
 
-from tests.factories import (
+from tests.factories import UserFactory, WorkspaceFactory
-    RequestFactory,
-    UserFactory,
-    WorkspaceFactory,
-    EnvironmentFactory,
-    ProjectFactory,
-)
 
 
 def test_update_environment_roles():
     owner = UserFactory.create()
-    developer_data = {
+    developer = UserFactory.from_atat_role("developer")
-        "dod_id": "1234567890",
-        "first_name": "Test",
-        "last_name": "User",
-        "email": "test.user@mail.com",
-        "workspace_role": "developer",
-    }
 
-    workspace = Workspaces.create(RequestFactory.create(creator=owner))
+    workspace = WorkspaceFactory.create(
-    workspace_user = Workspaces.create_member(owner, workspace, developer_data)
+        owner=owner,
-    project = Projects.create(
+        members=[{"user": developer, "role_name": "developer"}],
-        owner, workspace, "my test project", "It's mine.", ["dev", "staging", "prod"]
+        projects=[
+            {
+                "name": "project1",
+                "environments": [
+                    {
+                        "name": "project1 dev",
+                        "members": [{"user": developer, "role_name": "devlops"}],
+                    },
+                    {
+                        "name": "project1 staging",
+                        "members": [{"user": developer, "role_name": "developer"}],
+                    },
+                    {"name": "project1 prod"},
+                ],
+            }
+        ],
     )
 
-    dev_env = project.environments[0]
+    dev_env = workspace.projects[0].environments[0]
-    staging_env = project.environments[1]
+    staging_env = workspace.projects[0].environments[1]
-    Environments.add_member(dev_env, workspace_user.user, "devops")
-    Environments.add_member(staging_env, workspace_user.user, "developer")
-
     new_ids_and_roles = [
         {"id": dev_env.id, "role": "billing_admin"},
         {"id": staging_env.id, "role": "developer"},
     ]
 
+    workspace_user = workspace.members[0]
     Environments.update_environment_role(owner, new_ids_and_roles, workspace_user)
     new_dev_env_role = EnvironmentRoles.get(workspace_user.user.id, dev_env.id)
     staging_env_role = EnvironmentRoles.get(workspace_user.user.id, staging_env.id)
@@ -55,20 +47,36 @@ def test_update_environment_roles():
 
 def test_get_scoped_environments(db):
     developer = UserFactory.create()
-    workspace = WorkspaceFactory.create()
+    workspace = WorkspaceFactory.create(
-    workspace_user = Workspaces.add_member(workspace, developer, "developer")
+        members=[{"user": developer, "role_name": "developer"}],
-    project1 = ProjectFactory.create(workspace=workspace)
+        projects=[
-    project2 = ProjectFactory.create(workspace=workspace)
+            {
-    env1 = EnvironmentFactory.create(project=project1, name="project1 dev")
+                "name": "project1",
-    env2 = EnvironmentFactory.create(project=project1, name="project1 staging")
+                "environments": [
-    env3 = EnvironmentFactory.create(project=project2, name="project2 dev")
+                    {
-    env4 = EnvironmentFactory.create(project=project2, name="project2 staging")
+                        "name": "project1 dev",
-    db.session.add(EnvironmentRole(user=developer, environment=env1, role="developer"))
+                        "members": [{"user": developer, "role_name": "developer"}],
-    db.session.add(EnvironmentRole(user=developer, environment=env4, role="developer"))
+                    },
-    db.session.commit()
+                    {"name": "project1 staging"},
+                    {"name": "project1 prod"},
+                ],
+            },
+            {
+                "name": "project2",
+                "environments": [
+                    {"name": "project2 dev"},
+                    {
+                        "name": "project2 staging",
+                        "members": [{"user": developer, "role_name": "developer"}],
+                    },
+                    {"name": "project2 prod"},
+                ],
+            },
+        ],
+    )
 
-    project1_envs = Environments.for_user(developer, project1)
+    project1_envs = Environments.for_user(developer, workspace.projects[0])
     assert [env.name for env in project1_envs] == ["project1 dev"]
 
-    project2_envs = Environments.for_user(developer, project2)
+    project2_envs = Environments.for_user(developer, workspace.projects[1])
     assert [env.name for env in project2_envs] == ["project2 staging"]

tests/domain/test_projects.py

@@ -1,5 +1,5 @@
 from atst.domain.projects import Projects
-from tests.factories import RequestFactory, UserFactory
+from tests.factories import RequestFactory, UserFactory, WorkspaceFactory
 from atst.domain.workspaces import Workspaces
 
 
@@ -18,12 +18,9 @@ def test_create_project_with_multiple_environments():
 
 def test_workspace_owner_can_view_environments():
     owner = UserFactory.create()
-    request = RequestFactory.create(creator=owner)
+    workspace = WorkspaceFactory.create(
-    workspace = Workspaces.create(request)
+        owner=owner, projects=[{"environments": [{"name": "dev"}, {"name": "prod"}]}]
-    _project = Projects.create(
-        owner, workspace, "My Test Project", "Test", ["dev", "prod"]
     )
-
+    project = Projects.get(owner, workspace, workspace.projects[0].id)
-    project = Projects.get(owner, workspace, _project.id)
 
     assert len(project.environments) == 2

tests/factories.py

@@ -18,6 +18,8 @@ from atst.models.user import User
 from atst.models.role import Role
 from atst.models.workspace import Workspace
 from atst.domain.roles import Roles
+from atst.models.workspace_role import WorkspaceRole
+from atst.models.environment_role import EnvironmentRole
 
 
 class Base(factory.alchemy.SQLAlchemyModelFactory):
@@ -102,6 +104,12 @@ class RequestFactory(Base):
     class Params:
         initial_revision = None
 
+    @classmethod
+    def _adjust_kwargs(cls, **kwargs):
+        if kwargs.pop("with_task_order", False) and "task_order" not in kwargs:
+            kwargs["task_order"] = TaskOrderFactory.build()
+        return kwargs
+
     @classmethod
     def create_initial_status_event(cls, request):
         return RequestStatusEventFactory(
@@ -216,10 +224,38 @@ class WorkspaceFactory(Base):
     class Meta:
         model = Workspace
 
-    request = factory.SubFactory(RequestFactory)
+    request = factory.SubFactory(RequestFactory, with_task_order=True)
     # name it the same as the request ID by default
     name = factory.LazyAttribute(lambda w: w.request.id)
 
+    @classmethod
+    def _create(cls, model_class, *args, **kwargs):
+        with_projects = kwargs.pop("projects", [])
+        owner = kwargs.pop("owner", None)
+        members = kwargs.pop("members", [])
+
+        workspace = super()._create(model_class, *args, **kwargs)
+
+        projects = [
+            ProjectFactory.create(workspace=workspace, **p) for p in with_projects
+        ]
+
+        if owner:
+            workspace.request.creator = owner
+            WorkspaceRoleFactory.create(
+                workspace=workspace, role=Roles.get("owner"), user=owner
+            )
+
+        for member in members:
+            user = member.get("user", UserFactory.create())
+            role_name = member["role_name"]
+            WorkspaceRoleFactory.create(
+                workspace=workspace, role=Roles.get(role_name), user=user
+            )
+
+        workspace.projects = projects
+        return workspace
+
 
 class ProjectFactory(Base):
     class Meta:
@@ -229,7 +265,51 @@ class ProjectFactory(Base):
     name = factory.Faker("name")
     description = "A test project"
 
+    @classmethod
+    def _create(cls, model_class, *args, **kwargs):
+        with_environments = kwargs.pop("environments", [])
+        project = super()._create(model_class, *args, **kwargs)
+
+        environments = [
+            EnvironmentFactory.create(project=project, **e) for e in with_environments
+        ]
+
+        project.environments = environments
+        return project
+
 
 class EnvironmentFactory(Base):
     class Meta:
         model = Environment
+
+    @classmethod
+    def _create(cls, model_class, *args, **kwargs):
+        with_members = kwargs.pop("members", [])
+        environment = super()._create(model_class, *args, **kwargs)
+
+        for member in with_members:
+            user = member.get("user", UserFactory.create())
+            role_name = member["role_name"]
+            EnvironmentRoleFactory.create(
+                environment=environment, role=role_name, user=user
+            )
+
+        return environment
+
+
+class WorkspaceRoleFactory(Base):
+    class Meta:
+        model = WorkspaceRole
+
+    workspace = factory.SubFactory(WorkspaceFactory)
+    role = factory.SubFactory(RoleFactory)
+    user = factory.SubFactory(UserFactory)
+
+
+class EnvironmentRoleFactory(Base):
+    class Meta:
+        model = EnvironmentRole
+
+    environment = factory.SubFactory(EnvironmentFactory)
+    role = factory.Faker("name")
+    user = factory.SubFactory(UserFactory)