pk/atst
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
Refactor factories to make test setup more declarative
This commit is contained in:
richard-dds 2018-10-09 10:21:30 -04:00 committed by GitHub
commit 2966862413
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 138 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

98
tests/domain/test_environments.py
View File

@ -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 (
RequestFactory,
UserFactory,
WorkspaceFactory,
EnvironmentFactory,
ProjectFactory,
)
from tests.factories import UserFactory, WorkspaceFactory
def test_update_environment_roles():
owner = UserFactory.create()
developer_data = {
"dod_id": "1234567890",
"first_name": "Test",
"last_name": "User",
"email": "test.user@mail.com",
"workspace_role": "developer",
}
developer = UserFactory.from_atat_role("developer")
workspace = Workspaces.create(RequestFactory.create(creator=owner))
workspace_user = Workspaces.create_member(owner, workspace, developer_data)
project = Projects.create(
owner, workspace, "my test project", "It's mine.", ["dev", "staging", "prod"]
workspace = WorkspaceFactory.create(
owner=owner,
members=[{"user": developer, "role_name": "developer"}],
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]
staging_env = project.environments[1]
Environments.add_member(dev_env, workspace_user.user, "devops")
Environments.add_member(staging_env, workspace_user.user, "developer")
dev_env = workspace.projects[0].environments[0]
staging_env = workspace.projects[0].environments[1]
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_user = Workspaces.add_member(workspace, developer, "developer")
project1 = ProjectFactory.create(workspace=workspace)
project2 = ProjectFactory.create(workspace=workspace)
env1 = EnvironmentFactory.create(project=project1, name="project1 dev")
env2 = EnvironmentFactory.create(project=project1, name="project1 staging")
env3 = EnvironmentFactory.create(project=project2, name="project2 dev")
env4 = EnvironmentFactory.create(project=project2, name="project2 staging")
db.session.add(EnvironmentRole(user=developer, environment=env1, role="developer"))
db.session.add(EnvironmentRole(user=developer, environment=env4, role="developer"))
db.session.commit()
workspace = WorkspaceFactory.create(
members=[{"user": developer, "role_name": "developer"}],
projects=[
{
"name": "project1",
"environments": [
{
"name": "project1 dev",
"members": [{"user": developer, "role_name": "developer"}],
},
{"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"]

11
tests/domain/test_projects.py
View File

@ -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 = Workspaces.create(request)
_project = Projects.create(
owner, workspace, "My Test Project", "Test", ["dev", "prod"]
workspace = WorkspaceFactory.create(
owner=owner, projects=[{"environments": [{"name": "dev"}, {"name": "prod"}]}]
)
project = Projects.get(owner, workspace, _project.id)
project = Projects.get(owner, workspace, workspace.projects[0].id)
assert len(project.environments) == 2

82
tests/factories.py
View File

@ -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)