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

workspace -> portfolio everywhere

Browse Source
This commit is contained in:
dandds
2019-01-11 09:58:00 -05:00
parent 3fc323d785
commit d3d36822df
122 changed files with 2156 additions and 2129 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
tests/models/test_environments.py
View File

@@ -1,5 +1,5 @@
from atst.domain.environments import Environments
from atst.domain.workspaces import Workspaces
from atst.domain.portfolios import Portfolios
from atst.domain.applications import Applications
from tests.factories import RequestFactory, UserFactory
@@ -8,10 +8,10 @@ def test_add_user_to_environment():
owner = UserFactory.create()
developer = UserFactory.from_atat_role("developer")
workspace = Workspaces.create_from_request(RequestFactory.create(creator=owner))
portfolio = Portfolios.create_from_request(RequestFactory.create(creator=owner))
application = Applications.create(
owner,
workspace,
portfolio,
"my test application",
"It's mine.",
["dev", "staging", "prod"],

30
tests/models/test_invitation.py
View File

@@ -2,44 +2,44 @@ import pytest
import datetime
from atst.models.invitation import Invitation, Status
from atst.models.workspace_role import Status as WorkspaceRoleStatus
from atst.models.portfolio_role import Status as PortfolioRoleStatus
from tests.factories import (
InvitationFactory,
WorkspaceFactory,
PortfolioFactory,
UserFactory,
WorkspaceRoleFactory,
PortfolioRoleFactory,
)
def test_expired_invite_is_not_revokable():
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(
expiration_time=datetime.datetime.now() - datetime.timedelta(minutes=60),
workspace_role=ws_role,
portfolio_role=ws_role,
)
assert not invite.is_revokable
def test_unexpired_invite_is_revokable():
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(workspace_role=ws_role)
invite = InvitationFactory.create(portfolio_role=ws_role)
assert invite.is_revokable
def test_invite_is_not_revokable_if_invite_is_not_pending():
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(workspace_role=ws_role, status=Status.ACCEPTED)
invite = InvitationFactory.create(portfolio_role=ws_role, status=Status.ACCEPTED)
assert not invite.is_revokable

150
tests/models/test_workspace_role.py → tests/models/test_portfolio_role.py
View File

@@ -1,36 +1,36 @@
import datetime
from atst.domain.environments import Environments
from atst.domain.workspaces import Workspaces
from atst.domain.portfolios import Portfolios
from atst.domain.applications import Applications
from atst.models.workspace_role import Status
from atst.models.portfolio_role import Status
from atst.models.role import Role
from atst.models.invitation import Status as InvitationStatus
from atst.models.audit_event import AuditEvent
from atst.models.workspace_role import Status as WorkspaceRoleStatus
from atst.models.portfolio_role import Status as PortfolioRoleStatus
from tests.factories import (
RequestFactory,
UserFactory,
InvitationFactory,
WorkspaceRoleFactory,
PortfolioRoleFactory,
EnvironmentFactory,
EnvironmentRoleFactory,
ApplicationFactory,
WorkspaceFactory,
PortfolioFactory,
)
from atst.domain.workspace_roles import WorkspaceRoles
from atst.domain.portfolio_roles import PortfolioRoles
def test_has_no_ws_role_history(session):
owner = UserFactory.create()
user = UserFactory.create()
workspace = Workspaces.create_from_request(RequestFactory.create(creator=owner))
workspace_role = WorkspaceRoles.add(user, workspace.id, "developer")
portfolio = Portfolios.create_from_request(RequestFactory.create(creator=owner))
portfolio_role = PortfolioRoles.add(user, portfolio.id, "developer")
create_event = (
session.query(AuditEvent)
.filter(
AuditEvent.resource_id == workspace_role.id, AuditEvent.action == "create"
AuditEvent.resource_id == portfolio_role.id, AuditEvent.action == "create"
)
.one()
)
@@ -42,19 +42,19 @@ def test_has_ws_role_history(session):
owner = UserFactory.create()
user = UserFactory.create()
workspace = Workspaces.create_from_request(RequestFactory.create(creator=owner))
portfolio = Portfolios.create_from_request(RequestFactory.create(creator=owner))
role = session.query(Role).filter(Role.name == "developer").one()
# in order to get the history, we don't want the WorkspaceRoleFactory
# in order to get the history, we don't want the PortfolioRoleFactory
# to commit after create()
WorkspaceRoleFactory._meta.sqlalchemy_session_persistence = "flush"
workspace_role = WorkspaceRoleFactory.create(
workspace=workspace, user=user, role=role
PortfolioRoleFactory._meta.sqlalchemy_session_persistence = "flush"
portfolio_role = PortfolioRoleFactory.create(
portfolio=portfolio, user=user, role=role
)
WorkspaceRoles.update_role(workspace_role, "admin")
PortfolioRoles.update_role(portfolio_role, "admin")
changed_events = (
session.query(AuditEvent)
.filter(
AuditEvent.resource_id == workspace_role.id, AuditEvent.action == "update"
AuditEvent.resource_id == portfolio_role.id, AuditEvent.action == "update"
)
.all()
)
@@ -67,16 +67,16 @@ def test_has_ws_status_history(session):
owner = UserFactory.create()
user = UserFactory.create()
workspace = Workspaces.create_from_request(RequestFactory.create(creator=owner))
# in order to get the history, we don't want the WorkspaceRoleFactory
portfolio = Portfolios.create_from_request(RequestFactory.create(creator=owner))
# in order to get the history, we don't want the PortfolioRoleFactory
# to commit after create()
WorkspaceRoleFactory._meta.sqlalchemy_session_persistence = "flush"
workspace_role = WorkspaceRoleFactory.create(workspace=workspace, user=user)
WorkspaceRoles.enable(workspace_role)
PortfolioRoleFactory._meta.sqlalchemy_session_persistence = "flush"
portfolio_role = PortfolioRoleFactory.create(portfolio=portfolio, user=user)
PortfolioRoles.enable(portfolio_role)
changed_events = (
session.query(AuditEvent)
.filter(
AuditEvent.resource_id == workspace_role.id, AuditEvent.action == "update"
AuditEvent.resource_id == portfolio_role.id, AuditEvent.action == "update"
)
.all()
)
@@ -89,8 +89,8 @@ def test_has_ws_status_history(session):
def test_has_no_env_role_history(session):
owner = UserFactory.create()
user = UserFactory.create()
workspace = Workspaces.create_from_request(RequestFactory.create(creator=owner))
application = ApplicationFactory.create(workspace=workspace)
portfolio = Portfolios.create_from_request(RequestFactory.create(creator=owner))
application = ApplicationFactory.create(portfolio=portfolio)
environment = EnvironmentFactory.create(
application=application, name="new environment!"
)
@@ -110,9 +110,9 @@ def test_has_no_env_role_history(session):
def test_has_env_role_history(session):
owner = UserFactory.create()
user = UserFactory.create()
workspace = Workspaces.create_from_request(RequestFactory.create(creator=owner))
workspace_role = WorkspaceRoleFactory.create(workspace=workspace, user=user)
application = ApplicationFactory.create(workspace=workspace)
portfolio = Portfolios.create_from_request(RequestFactory.create(creator=owner))
portfolio_role = PortfolioRoleFactory.create(portfolio=portfolio, user=user)
application = ApplicationFactory.create(portfolio=portfolio)
environment = EnvironmentFactory.create(
application=application, name="new environment!"
)
@@ -121,7 +121,7 @@ def test_has_env_role_history(session):
user=user, environment=environment, role="developer"
)
Environments.update_environment_roles(
owner, workspace, workspace_role, [{"role": "admin", "id": environment.id}]
owner, portfolio, portfolio_role, [{"role": "admin", "id": environment.id}]
)
changed_events = (
session.query(AuditEvent)
@@ -137,11 +137,11 @@ def test_event_details():
owner = UserFactory.create()
user = UserFactory.create()
workspace = Workspaces.create_from_request(RequestFactory.create(creator=owner))
workspace_role = WorkspaceRoles.add(user, workspace.id, "developer")
portfolio = Portfolios.create_from_request(RequestFactory.create(creator=owner))
portfolio_role = PortfolioRoles.add(user, portfolio.id, "developer")
assert workspace_role.event_details["updated_user_name"] == user.displayname
assert workspace_role.event_details["updated_user_id"] == str(user.id)
assert portfolio_role.event_details["updated_user_name"] == user.displayname
assert portfolio_role.event_details["updated_user_id"] == str(user.id)
def test_has_no_environment_roles():
@@ -151,13 +151,13 @@ def test_has_no_environment_roles():
"first_name": "Test",
"last_name": "User",
"email": "test.user@mail.com",
"workspace_role": "developer",
"portfolio_role": "developer",
}
workspace = Workspaces.create_from_request(RequestFactory.create(creator=owner))
workspace_role = Workspaces.create_member(owner, workspace, developer_data)
portfolio = Portfolios.create_from_request(RequestFactory.create(creator=owner))
portfolio_role = Portfolios.create_member(owner, portfolio, developer_data)
assert not workspace_role.has_environment_roles
assert not portfolio_role.has_environment_roles
def test_has_environment_roles():
@@ -167,22 +167,22 @@ def test_has_environment_roles():
"first_name": "Test",
"last_name": "User",
"email": "test.user@mail.com",
"workspace_role": "developer",
"portfolio_role": "developer",
}
workspace = Workspaces.create_from_request(RequestFactory.create(creator=owner))
workspace_role = Workspaces.create_member(owner, workspace, developer_data)
portfolio = Portfolios.create_from_request(RequestFactory.create(creator=owner))
portfolio_role = Portfolios.create_member(owner, portfolio, developer_data)
application = Applications.create(
owner,
workspace,
portfolio,
"my test application",
"It's mine.",
["dev", "staging", "prod"],
)
Environments.add_member(
application.environments[0], workspace_role.user, "developer"
application.environments[0], portfolio_role.user, "developer"
)
assert workspace_role.has_environment_roles
assert portfolio_role.has_environment_roles
def test_role_displayname():
@@ -192,84 +192,84 @@ def test_role_displayname():
"first_name": "Test",
"last_name": "User",
"email": "test.user@mail.com",
"workspace_role": "developer",
"portfolio_role": "developer",
}
workspace = Workspaces.create_from_request(RequestFactory.create(creator=owner))
workspace_role = Workspaces.create_member(owner, workspace, developer_data)
portfolio = Portfolios.create_from_request(RequestFactory.create(creator=owner))
portfolio_role = Portfolios.create_member(owner, portfolio, developer_data)
assert workspace_role.role_displayname == "Developer"
assert portfolio_role.role_displayname == "Developer"
def test_status_when_member_is_active():
workspace_role = WorkspaceRoleFactory.create(status=Status.ACTIVE)
assert workspace_role.display_status == "Active"
portfolio_role = PortfolioRoleFactory.create(status=Status.ACTIVE)
assert portfolio_role.display_status == "Active"
def test_status_when_invitation_has_been_rejected_for_expirations():
workspace = WorkspaceFactory.create()
portfolio = PortfolioFactory.create()
user = UserFactory.create()
workspace_role = WorkspaceRoleFactory.create(
workspace=workspace, user=user, status=WorkspaceRoleStatus.PENDING
portfolio_role = PortfolioRoleFactory.create(
portfolio=portfolio, user=user, status=PortfolioRoleStatus.PENDING
)
invitation = InvitationFactory.create(
workspace_role=workspace_role, status=InvitationStatus.REJECTED_EXPIRED
portfolio_role=portfolio_role, status=InvitationStatus.REJECTED_EXPIRED
)
assert workspace_role.display_status == "Invite expired"
assert portfolio_role.display_status == "Invite expired"
def test_status_when_invitation_has_been_rejected_for_wrong_user():
workspace = WorkspaceFactory.create()
portfolio = PortfolioFactory.create()
user = UserFactory.create()
workspace_role = WorkspaceRoleFactory.create(
workspace=workspace, user=user, status=WorkspaceRoleStatus.PENDING
portfolio_role = PortfolioRoleFactory.create(
portfolio=portfolio, user=user, status=PortfolioRoleStatus.PENDING
)
invitation = InvitationFactory.create(
workspace_role=workspace_role, status=InvitationStatus.REJECTED_WRONG_USER
portfolio_role=portfolio_role, status=InvitationStatus.REJECTED_WRONG_USER
)
assert workspace_role.display_status == "Error on invite"
assert portfolio_role.display_status == "Error on invite"
def test_status_when_invitation_is_expired():
workspace = WorkspaceFactory.create()
portfolio = PortfolioFactory.create()
user = UserFactory.create()
workspace_role = WorkspaceRoleFactory.create(
workspace=workspace, user=user, status=WorkspaceRoleStatus.PENDING
portfolio_role = PortfolioRoleFactory.create(
portfolio=portfolio, user=user, status=PortfolioRoleStatus.PENDING
)
invitation = InvitationFactory.create(
workspace_role=workspace_role,
portfolio_role=portfolio_role,
status=InvitationStatus.PENDING,
expiration_time=datetime.datetime.now() - datetime.timedelta(seconds=1),
)
assert workspace_role.display_status == "Invite expired"
assert portfolio_role.display_status == "Invite expired"
def test_can_not_resend_invitation_if_active():
workspace = WorkspaceFactory.create()
portfolio = PortfolioFactory.create()
user = UserFactory.create()
workspace_role = WorkspaceRoleFactory.create(
workspace=workspace, user=user, status=WorkspaceRoleStatus.PENDING
portfolio_role = PortfolioRoleFactory.create(
portfolio=portfolio, user=user, status=PortfolioRoleStatus.PENDING
)
invitation = InvitationFactory.create(
workspace_role=workspace_role, status=InvitationStatus.ACCEPTED
portfolio_role=portfolio_role, status=InvitationStatus.ACCEPTED
)
assert not workspace_role.can_resend_invitation
assert not portfolio_role.can_resend_invitation
def test_can_resend_invitation_if_expired():
workspace = WorkspaceFactory.create()
portfolio = PortfolioFactory.create()
user = UserFactory.create()
workspace_role = WorkspaceRoleFactory.create(
workspace=workspace, user=user, status=WorkspaceRoleStatus.PENDING
portfolio_role = PortfolioRoleFactory.create(
portfolio=portfolio, user=user, status=PortfolioRoleStatus.PENDING
)
invitation = InvitationFactory.create(
workspace_role=workspace_role, status=InvitationStatus.REJECTED_EXPIRED
portfolio_role=portfolio_role, status=InvitationStatus.REJECTED_EXPIRED
)
assert workspace_role.can_resend_invitation
assert portfolio_role.can_resend_invitation
def test_can_list_all_environments():
workspace = WorkspaceFactory.create(
portfolio = PortfolioFactory.create(
applications=[
{
"name": "application1",
@@ -298,4 +298,4 @@ def test_can_list_all_environments():
]
)
assert len(workspace.all_environments) == 9
assert len(portfolio.all_environments) == 9