chore: 纳入本地 Dify 1.19.0 源码及品牌与免登改动
演示目录只保留可重建的源码。运行密钥、数据卷、依赖和带口令的本地配置不进入仓库。 Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
1 parent
60158935f4
commit
6519682885
15831 files changed
+3063428
No files matched your search
Whitespace-only changes.
@@ -0,0 +1,466 @@
|
||||
from collections.abc import Callable
|
||||
from unittest.mock import Mock, create_autospec
|
||||
|
||||
import pytest
|
||||
|
||||
from enums import CloudPlan, DeploymentEdition
|
||||
from extensions.ext_redis import RedisClientWrapper
|
||||
from machinery.context import RequestContext
|
||||
from models.account import Account
|
||||
from services.account.adapters import RedisInvitationTokenStore
|
||||
from services.credit_pool_service import CreditPoolBalance
|
||||
from services.enterprise.base import EnterpriseRequest
|
||||
from services.enterprise.enterprise_service import WorkspacePermission
|
||||
from services.entities.feature_entities import FeatureModel, LicenseLimitationModel, LicenseModel, LimitationModel
|
||||
from services.errors.base import NoPermissionError
|
||||
from services.errors.workspace import WorkspaceInvitationQuotaError, WorkspaceMemberLicenseQuotaError
|
||||
from services.file_service import FileService
|
||||
from services.workspace import gateways
|
||||
from services.workspace.contracts import WorkspaceMemberRole, WorkspaceMemberRoleSubject
|
||||
from services.workspace.gateways import (
|
||||
DeploymentWorkspaceFeatureGateway,
|
||||
DeploymentWorkspaceMemberRoleResolver,
|
||||
DeploymentWorkspacePlanGateway,
|
||||
WorkspaceFileGateway,
|
||||
)
|
||||
from tests.helpers import billing_builders as builders
|
||||
from tests.helpers.unit.account_domain import AccountDomain
|
||||
from tests.helpers.unit.rbac_fakes import RBACTransport
|
||||
|
||||
"""Workspace policies and notifications with only external clients replaced."""
|
||||
|
||||
|
||||
class TestGatewaysCases:
|
||||
@staticmethod
|
||||
@pytest.fixture
|
||||
def invitations() -> gateways.WorkspaceInvitationGateway:
|
||||
redis = create_autospec(RedisClientWrapper, instance=True)
|
||||
return gateways.WorkspaceInvitationGateway(tokens=RedisInvitationTokenStore(redis=redis), redis=redis)
|
||||
|
||||
@staticmethod
|
||||
@pytest.mark.parametrize("allowed", [True, False])
|
||||
def test_invitation_policy_exposes_domain_errors(
|
||||
invitations: gateways.WorkspaceInvitationGateway,
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
config_overrides: Callable[..., None],
|
||||
allowed: bool,
|
||||
) -> None:
|
||||
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.ENTERPRISE)
|
||||
requested: list[str] = []
|
||||
|
||||
def get_permission(workspace_id: str) -> WorkspacePermission:
|
||||
requested.append(workspace_id)
|
||||
return WorkspacePermission(workspaceId=workspace_id, allowMemberInvite=allowed)
|
||||
|
||||
monkeypatch.setattr(gateways.EnterpriseService.WorkspacePermissionService, "get_permission", get_permission)
|
||||
if allowed:
|
||||
invitations.ensure_allowed("workspace")
|
||||
else:
|
||||
with pytest.raises(NoPermissionError, match="Workspace policy prohibits member invitations"):
|
||||
invitations.ensure_allowed("workspace")
|
||||
assert requested == ["workspace"]
|
||||
|
||||
@staticmethod
|
||||
@pytest.mark.parametrize(("limit", "allowed"), [(0, True), (-1, True), (4, True), (5, True), (3, False)])
|
||||
def test_cloud_invitation_member_limit(
|
||||
invitations: gateways.WorkspaceInvitationGateway,
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
config_overrides: Callable[..., None],
|
||||
limit: int,
|
||||
allowed: bool,
|
||||
) -> None:
|
||||
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD)
|
||||
# Use the repository's current count, not a potentially stale billing size.
|
||||
features = Mock(return_value=FeatureModel(members=LimitationModel(size=99, limit=limit)))
|
||||
license_query = create_autospec(gateways.SystemFeatureService.get_license, instance=True)
|
||||
monkeypatch.setattr(gateways.FeatureService, "get_features", features)
|
||||
monkeypatch.setattr(gateways.SystemFeatureService, "get_license", license_query)
|
||||
|
||||
assert invitations.requires_capacity_check
|
||||
if allowed:
|
||||
invitations.check_capacity("workspace", current_members=2, new_members=2, new_accounts=1)
|
||||
else:
|
||||
with pytest.raises(WorkspaceInvitationQuotaError) as error:
|
||||
invitations.check_capacity("workspace", current_members=2, new_members=2, new_accounts=1)
|
||||
assert error.value.seats is False
|
||||
features.assert_called_once_with(tenant_id="workspace", exclude_vector_space=True)
|
||||
license_query.assert_not_called()
|
||||
|
||||
@staticmethod
|
||||
@pytest.mark.parametrize(
|
||||
("member_quota", "seat_quota", "new_accounts", "failure"),
|
||||
[
|
||||
(
|
||||
LicenseLimitationModel(enabled=True, size=2, limit=4),
|
||||
LicenseLimitationModel(enabled=True, size=9, limit=10),
|
||||
1,
|
||||
None,
|
||||
),
|
||||
(
|
||||
LicenseLimitationModel(enabled=True, size=3, limit=4),
|
||||
LicenseLimitationModel(enabled=True, size=9, limit=10),
|
||||
1,
|
||||
"members",
|
||||
),
|
||||
(LicenseLimitationModel(), LicenseLimitationModel(enabled=True, size=10, limit=10), 1, "seats"),
|
||||
(LicenseLimitationModel(), LicenseLimitationModel(enabled=True, size=9, limit=10), 2, "seats"),
|
||||
(LicenseLimitationModel(), LicenseLimitationModel(enabled=True, size=8, limit=10), 2, None),
|
||||
(LicenseLimitationModel(), LicenseLimitationModel(enabled=True, size=10, limit=10), 0, None),
|
||||
(
|
||||
LicenseLimitationModel(enabled=True, size=99, limit=0),
|
||||
LicenseLimitationModel(enabled=True, size=99, limit=0),
|
||||
2,
|
||||
None,
|
||||
),
|
||||
(
|
||||
LicenseLimitationModel(enabled=False, size=99, limit=1),
|
||||
LicenseLimitationModel(enabled=False, size=99, limit=1),
|
||||
2,
|
||||
None,
|
||||
),
|
||||
],
|
||||
ids=[
|
||||
"exact-capacity",
|
||||
"workspace-full",
|
||||
"seats-full",
|
||||
"not-enough-seats-for-batch",
|
||||
"exact-seats-for-batch",
|
||||
"existing-accounts",
|
||||
"unlimited",
|
||||
"disabled",
|
||||
],
|
||||
)
|
||||
def test_enterprise_invitation_member_and_seat_limits(
|
||||
invitations: gateways.WorkspaceInvitationGateway,
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
config_overrides: Callable[..., None],
|
||||
member_quota: LicenseLimitationModel,
|
||||
seat_quota: LicenseLimitationModel,
|
||||
new_accounts: int,
|
||||
failure: str | None,
|
||||
) -> None:
|
||||
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.ENTERPRISE)
|
||||
monkeypatch.setattr(
|
||||
gateways.FeatureService, "get_features", Mock(return_value=FeatureModel(workspace_members=member_quota))
|
||||
)
|
||||
license_query = Mock(return_value=LicenseModel(seats=seat_quota))
|
||||
monkeypatch.setattr(gateways.SystemFeatureService, "get_license", license_query)
|
||||
|
||||
assert invitations.requires_capacity_check
|
||||
if failure is None:
|
||||
invitations.check_capacity("workspace", current_members=2, new_members=2, new_accounts=new_accounts)
|
||||
else:
|
||||
with pytest.raises(WorkspaceInvitationQuotaError) as error:
|
||||
invitations.check_capacity("workspace", current_members=2, new_members=2, new_accounts=new_accounts)
|
||||
assert error.value.seats is (failure == "seats")
|
||||
assert license_query.call_count == int(new_accounts > 0 and failure != "members")
|
||||
|
||||
@staticmethod
|
||||
def test_community_invitation_does_not_query_quotas(
|
||||
invitations: gateways.WorkspaceInvitationGateway,
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
config_overrides: Callable[..., None],
|
||||
) -> None:
|
||||
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY)
|
||||
features = create_autospec(gateways.FeatureService.get_features, instance=True)
|
||||
license_query = create_autospec(gateways.SystemFeatureService.get_license, instance=True)
|
||||
monkeypatch.setattr(gateways.FeatureService, "get_features", features)
|
||||
monkeypatch.setattr(gateways.SystemFeatureService, "get_license", license_query)
|
||||
|
||||
assert not invitations.requires_capacity_check
|
||||
invitations.check_capacity("workspace", current_members=2, new_members=2, new_accounts=1)
|
||||
features.assert_not_called()
|
||||
license_query.assert_not_called()
|
||||
|
||||
@staticmethod
|
||||
@pytest.mark.parametrize(
|
||||
("edition", "plan_limit", "license_quota", "error"),
|
||||
[
|
||||
(DeploymentEdition.CLOUD, 2, LicenseLimitationModel(), WorkspaceInvitationQuotaError),
|
||||
(DeploymentEdition.CLOUD, 3, LicenseLimitationModel(), None),
|
||||
(DeploymentEdition.CLOUD, 0, LicenseLimitationModel(), None),
|
||||
(DeploymentEdition.CLOUD, -1, LicenseLimitationModel(), None),
|
||||
(
|
||||
DeploymentEdition.ENTERPRISE,
|
||||
2,
|
||||
LicenseLimitationModel(enabled=True, size=2, limit=2),
|
||||
WorkspaceMemberLicenseQuotaError,
|
||||
),
|
||||
(DeploymentEdition.ENTERPRISE, 2, LicenseLimitationModel(enabled=True, size=2, limit=3), None),
|
||||
(DeploymentEdition.ENTERPRISE, 2, LicenseLimitationModel(enabled=True, size=2, limit=0), None),
|
||||
(DeploymentEdition.COMMUNITY, 2, LicenseLimitationModel(enabled=False, size=2, limit=2), None),
|
||||
(
|
||||
DeploymentEdition.CLOUD,
|
||||
3,
|
||||
LicenseLimitationModel(enabled=True, size=2, limit=2),
|
||||
WorkspaceMemberLicenseQuotaError,
|
||||
),
|
||||
],
|
||||
)
|
||||
def test_single_invitation_quota_preserves_plan_and_license_limits(
|
||||
invitations: gateways.WorkspaceInvitationGateway,
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
config_overrides: Callable[..., None],
|
||||
edition: DeploymentEdition,
|
||||
plan_limit: int,
|
||||
license_quota: LicenseLimitationModel,
|
||||
error: type[WorkspaceInvitationQuotaError] | None,
|
||||
) -> None:
|
||||
config_overrides(DEPLOYMENT_EDITION=edition)
|
||||
features = FeatureModel(members=LimitationModel(size=2, limit=plan_limit), workspace_members=license_quota)
|
||||
requested: list[str] = []
|
||||
|
||||
def get_features(tenant_id: str, *, exclude_vector_space: bool = False) -> FeatureModel:
|
||||
requested.append(tenant_id)
|
||||
assert exclude_vector_space
|
||||
return features
|
||||
|
||||
monkeypatch.setattr(gateways.FeatureService, "get_features", get_features)
|
||||
|
||||
if error is None:
|
||||
invitations.check_invitation_quota("workspace")
|
||||
else:
|
||||
with pytest.raises(error):
|
||||
invitations.check_invitation_quota("workspace")
|
||||
assert requested == ["workspace"]
|
||||
|
||||
@staticmethod
|
||||
def test_owner_transfer_notifies_both_owners(
|
||||
account_domain: AccountDomain, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
old_owner = account_domain.accounts.create_account("old@example.com", "Old", "en-US")
|
||||
new_owner = account_domain.accounts.create_account("new@example.com", "New", "en-US")
|
||||
old_notification = create_autospec(gateways.send_old_owner_transfer_notify_email_task.delay, instance=True)
|
||||
new_notification = create_autospec(gateways.send_new_owner_transfer_notify_email_task.delay, instance=True)
|
||||
monkeypatch.setattr(gateways.send_old_owner_transfer_notify_email_task, "delay", old_notification)
|
||||
monkeypatch.setattr(gateways.send_new_owner_transfer_notify_email_task, "delay", new_notification)
|
||||
|
||||
gateway = gateways.WorkspaceOwnerTransferGateway(redis=create_autospec(RedisClientWrapper, instance=True))
|
||||
gateway.notify(old_owner=old_owner, new_owner=new_owner, workspace_name="Workspace")
|
||||
|
||||
new_notification.assert_called_once_with(language="en-US", to=new_owner.email, workspace="Workspace")
|
||||
old_notification.assert_called_once_with(
|
||||
language="en-US", to=old_owner.email, workspace="Workspace", new_owner_email=new_owner.email
|
||||
)
|
||||
|
||||
|
||||
"""Deployment billing adapter and paid-to-trial fallback regressions."""
|
||||
|
||||
|
||||
class TestWorkspaceCreditPoolCases:
|
||||
@staticmethod
|
||||
@pytest.mark.parametrize(
|
||||
("plan", "paid_quota", "paid_used", "trial_quota", "expected_type", "remaining"),
|
||||
[
|
||||
(CloudPlan.TEAM, 500, 120, 100, "paid", 380),
|
||||
(CloudPlan.TEAM, -1, 999, 100, "paid", -1),
|
||||
(CloudPlan.TEAM, 500, 500, 100, "trial", 60),
|
||||
(CloudPlan.TEAM, None, 0, 100, "trial", 60),
|
||||
(CloudPlan.SANDBOX, 500, 0, 100, "trial", 60),
|
||||
(CloudPlan.SANDBOX, None, 0, None, None, None),
|
||||
],
|
||||
)
|
||||
def test_effective_credit_pool(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
config_overrides: Callable[..., None],
|
||||
plan: CloudPlan,
|
||||
paid_quota: int | None,
|
||||
paid_used: int,
|
||||
trial_quota: int | None,
|
||||
expected_type: str | None,
|
||||
remaining: int | None,
|
||||
) -> None:
|
||||
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD)
|
||||
monkeypatch.setattr(
|
||||
gateways.BillingService,
|
||||
"get_info",
|
||||
lambda *_a, **_k: builders.subscription_info(plan, next_credit_reset_date=1775001600),
|
||||
)
|
||||
paid = CreditPoolBalance("tenant", "paid", paid_quota, paid_used) if paid_quota is not None else None
|
||||
trial = CreditPoolBalance("tenant", "trial", trial_quota, 40) if trial_quota is not None else None
|
||||
calls = []
|
||||
|
||||
def get_pool(*, tenant_id: str, pool_type: str) -> CreditPoolBalance | None:
|
||||
calls.append((tenant_id, pool_type))
|
||||
return paid if pool_type == "paid" else trial
|
||||
|
||||
monkeypatch.setattr(gateways.CreditPoolService, "get_pool", get_pool)
|
||||
result = DeploymentWorkspaceFeatureGateway().get_effective_credit_pool("tenant")
|
||||
assert result.pool_type == expected_type
|
||||
assert result.remaining_credits == remaining
|
||||
assert result.next_credit_reset_date == 1775001600
|
||||
if plan == CloudPlan.SANDBOX:
|
||||
assert calls == [("tenant", "trial")]
|
||||
elif expected_type == "paid":
|
||||
assert calls == [("tenant", "paid")]
|
||||
else:
|
||||
assert calls == [("tenant", "paid"), ("tenant", "trial")]
|
||||
|
||||
@staticmethod
|
||||
@pytest.mark.parametrize(
|
||||
("quota", "used", "exhausted_at", "expected"),
|
||||
[(100, 100, 123, 123), (100, 10, 123, None), (-1, 100, 123, None), (100, 100, 0, None)],
|
||||
)
|
||||
def test_feature_info_uses_same_pool_rules(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
config_overrides: Callable[..., None],
|
||||
quota: int,
|
||||
used: int,
|
||||
exhausted_at: int | None,
|
||||
expected: int | None,
|
||||
) -> None:
|
||||
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD)
|
||||
features = FeatureModel(can_replace_logo=True)
|
||||
monkeypatch.setattr(gateways.FeatureService, "get_features", lambda *_a, **_k: features)
|
||||
monkeypatch.setattr(
|
||||
gateways.CreditPoolService,
|
||||
"get_pool",
|
||||
lambda **_k: CreditPoolBalance("tenant", "trial", quota, used, exhausted_at),
|
||||
)
|
||||
result = DeploymentWorkspaceFeatureGateway().get_features("tenant")
|
||||
assert result.can_replace_logo
|
||||
assert result.credits.exhausted_at == expected
|
||||
|
||||
@staticmethod
|
||||
@pytest.mark.parametrize("edition", [DeploymentEdition.COMMUNITY, DeploymentEdition.ENTERPRISE])
|
||||
def test_non_cloud_summary_skips_external_io(
|
||||
monkeypatch: pytest.MonkeyPatch, config_overrides: Callable[..., None], edition: DeploymentEdition
|
||||
) -> None:
|
||||
config_overrides(DEPLOYMENT_EDITION=edition)
|
||||
billing = Mock(side_effect=AssertionError("billing must not be queried"))
|
||||
monkeypatch.setattr(gateways.BillingService, "get_info", billing)
|
||||
result = DeploymentWorkspaceFeatureGateway().get_effective_credit_pool("tenant")
|
||||
assert result.plan is None
|
||||
assert result.remaining_credits is None
|
||||
billing.assert_not_called()
|
||||
|
||||
@staticmethod
|
||||
@pytest.mark.parametrize(
|
||||
("edition", "bulk", "expected", "fallback_ids"),
|
||||
[
|
||||
(DeploymentEdition.CLOUD, {"w1": builders.plan_item("team")}, {"w1": "team", "w2": "professional"}, ["w2"]),
|
||||
(DeploymentEdition.CLOUD, {}, {"w1": "professional", "w2": "professional"}, ["w1", "w2"]),
|
||||
(DeploymentEdition.COMMUNITY, {}, {"w1": "professional", "w2": "professional"}, ["w1", "w2"]),
|
||||
(DeploymentEdition.ENTERPRISE, {}, {"w1": "sandbox", "w2": "sandbox"}, []),
|
||||
],
|
||||
)
|
||||
def test_plan_gateway_bulk_and_fallback(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
config_overrides: Callable[..., None],
|
||||
edition: DeploymentEdition,
|
||||
bulk: dict[str, dict[str, str]],
|
||||
expected: int | None,
|
||||
fallback_ids: list[str],
|
||||
) -> None:
|
||||
config_overrides(DEPLOYMENT_EDITION=edition)
|
||||
bulk_query = Mock(return_value=bulk)
|
||||
features = FeatureModel()
|
||||
features.billing.subscription.plan = CloudPlan.PROFESSIONAL
|
||||
feature_query = Mock(return_value=features)
|
||||
monkeypatch.setattr(gateways.BillingService, "get_plan_bulk", bulk_query)
|
||||
monkeypatch.setattr(gateways.FeatureService, "get_features", feature_query)
|
||||
assert DeploymentWorkspacePlanGateway().resolve_many(["w1", "w2"]) == expected
|
||||
assert [call.args[0] for call in feature_query.call_args_list] == fallback_ids
|
||||
assert bulk_query.call_count == int(edition == DeploymentEdition.CLOUD)
|
||||
|
||||
|
||||
"""File adapter keeps admitted identity explicit across the FileService boundary."""
|
||||
|
||||
|
||||
class TestWorkspaceFileGatewayCases:
|
||||
@staticmethod
|
||||
def test_upload_uses_admitted_account_and_explicit_workspace() -> None:
|
||||
files = create_autospec(FileService, instance=True)
|
||||
files.upload_file.return_value = Mock(id="file-id")
|
||||
gateway = WorkspaceFileGateway(files=files)
|
||||
context = RequestContext("request", None, "account", "workspace")
|
||||
|
||||
assert gateway.upload(context, filename="logo.png", content=b"image", mimetype="image/png") == "file-id"
|
||||
|
||||
kwargs = files.upload_file.call_args.kwargs
|
||||
assert isinstance(kwargs["user"], Account)
|
||||
assert kwargs["user"].id == "account"
|
||||
assert kwargs["tenant_id"] == "workspace"
|
||||
assert kwargs["content"] == b"image"
|
||||
|
||||
|
||||
def make_subject(account_id: str, *, legacy_role: str = "normal") -> WorkspaceMemberRoleSubject:
|
||||
return WorkspaceMemberRoleSubject(account_id=account_id, legacy_role=legacy_role)
|
||||
|
||||
|
||||
class RoleResolutionError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class TestWorkspaceMemberRoleResolverCases:
|
||||
@staticmethod
|
||||
@pytest.fixture
|
||||
def transport(monkeypatch: pytest.MonkeyPatch) -> RBACTransport:
|
||||
transport = RBACTransport()
|
||||
monkeypatch.setattr(EnterpriseRequest, "send_inner_rbac_request", transport.send)
|
||||
return transport
|
||||
|
||||
@staticmethod
|
||||
def test_builtin_mode_projects_join_roles_without_enterprise_call(
|
||||
config_overrides: Callable[..., None], transport: RBACTransport
|
||||
) -> None:
|
||||
config_overrides(RBAC_ENABLED=False)
|
||||
|
||||
result = DeploymentWorkspaceMemberRoleResolver().resolve_many(
|
||||
"workspace-1", "actor-1", [make_subject("owner", legacy_role="owner"), make_subject("member")]
|
||||
)
|
||||
|
||||
assert result == {
|
||||
"owner": (WorkspaceMemberRole(id="owner", name="owner"),),
|
||||
"member": (WorkspaceMemberRole(id="normal", name="normal"),),
|
||||
}
|
||||
assert transport.requests == []
|
||||
|
||||
@staticmethod
|
||||
@pytest.mark.parametrize("language", [None, "ja"])
|
||||
def test_rbac_mode_maps_batch_response_without_builtin_fallback(
|
||||
config_overrides: Callable[..., None], transport: RBACTransport, language: str | None
|
||||
) -> None:
|
||||
config_overrides(RBAC_ENABLED=True)
|
||||
transport.response = {
|
||||
"owner": [
|
||||
{"id": "workspace.owner", "name": "Owner", "type": "builtin"},
|
||||
{"id": "workspace.editor", "name": "Editor", "type": "builtin"},
|
||||
]
|
||||
}
|
||||
|
||||
result = DeploymentWorkspaceMemberRoleResolver().resolve_many(
|
||||
"workspace-1",
|
||||
"actor-1",
|
||||
[make_subject("owner", legacy_role="owner"), make_subject("omitted", legacy_role="admin")],
|
||||
language=language,
|
||||
)
|
||||
|
||||
assert result == {
|
||||
"owner": (
|
||||
WorkspaceMemberRole(id="workspace.owner", name="Owner"),
|
||||
WorkspaceMemberRole(id="workspace.editor", name="Editor"),
|
||||
)
|
||||
}
|
||||
sent = transport.only_request
|
||||
assert (sent.method, sent.endpoint) == ("POST", "/rbac/members/rbac-roles/batch")
|
||||
assert (sent.tenant_id, sent.account_id) == ("workspace-1", "actor-1")
|
||||
assert sent.json == {"member_ids": ["owner", "omitted"]}
|
||||
assert sent.params == ({"language": language} if language else None)
|
||||
|
||||
@staticmethod
|
||||
def test_rbac_failure_propagates(config_overrides: Callable[..., None], transport: RBACTransport) -> None:
|
||||
config_overrides(RBAC_ENABLED=True)
|
||||
transport.failure = RoleResolutionError("enterprise unavailable")
|
||||
|
||||
with pytest.raises(RoleResolutionError, match="enterprise unavailable"):
|
||||
DeploymentWorkspaceMemberRoleResolver().resolve_many("workspace-1", "actor-1", [make_subject("member-1")])
|
||||
|
||||
@staticmethod
|
||||
def test_empty_member_list_skips_enterprise_call(
|
||||
config_overrides: Callable[..., None], transport: RBACTransport
|
||||
) -> None:
|
||||
config_overrides(RBAC_ENABLED=True)
|
||||
|
||||
assert DeploymentWorkspaceMemberRoleResolver().resolve_many("workspace-1", "actor-1", []) == {}
|
||||
assert transport.requests == []
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,405 @@
|
||||
"""Internal provisioning policy and the existing tenant write path."""
|
||||
|
||||
from collections.abc import Callable
|
||||
from datetime import datetime
|
||||
from typing import cast
|
||||
from unittest.mock import Mock, create_autospec
|
||||
|
||||
import pytest
|
||||
from blinker import Signal
|
||||
from sqlalchemy import Select, event, select
|
||||
from sqlalchemy.dialects import postgresql
|
||||
from sqlalchemy.engine import Connection
|
||||
from sqlalchemy.orm import Mapper, ORMExecuteState, Session, sessionmaker
|
||||
|
||||
from enums import DeploymentEdition
|
||||
from models import TenantCreditPool
|
||||
from models.account import Account, Tenant, TenantAccountJoin, TenantAccountRole, TenantPluginAutoUpgradeStrategy
|
||||
from repositories.account.repository import SQLAlchemyAccountRepository
|
||||
from repositories.workspace.workspace_repository import WorkspaceRepository
|
||||
from services.account_errors import AccountNotFoundError
|
||||
from services.entities.account_entities import AccountSnapshot
|
||||
from services.entities.feature_entities import LicenseModel
|
||||
from services.errors.workspace import (
|
||||
InvalidWorkspaceMemberRoleError,
|
||||
WorkspaceNotFoundError,
|
||||
WorkspaceOwnerNotFoundError,
|
||||
)
|
||||
from services.workspace import gateways
|
||||
from services.workspace.contracts import CreatedWorkspace, WorkspaceCreation
|
||||
from services.workspace.gateways import WorkspaceProvisioningEffectsGateway
|
||||
from services.workspace.provisioning_service import (
|
||||
WorkspaceCreationPolicy,
|
||||
WorkspaceMembershipQuery,
|
||||
WorkspaceMemberWriter,
|
||||
WorkspaceOwnerQuery,
|
||||
WorkspaceProvisioningEffects,
|
||||
WorkspaceProvisioningService,
|
||||
WorkspaceProvisioningStore,
|
||||
)
|
||||
from tests.helpers.unit.account_domain import AccountDomain
|
||||
|
||||
OWNER = AccountSnapshot(
|
||||
"account",
|
||||
"Owner",
|
||||
"owner@example.com",
|
||||
None,
|
||||
False,
|
||||
"en-US",
|
||||
"light",
|
||||
"UTC",
|
||||
None,
|
||||
None,
|
||||
"active",
|
||||
datetime(2026, 1, 1),
|
||||
datetime(2026, 1, 1),
|
||||
)
|
||||
|
||||
|
||||
def test_owner_lookup_is_exact_and_tolerates_duplicate_emails(sqlite_session_factory: sessionmaker[Session]) -> None:
|
||||
with sqlite_session_factory() as session:
|
||||
first = Account(name="First", email="owner@example.com")
|
||||
second = Account(name="Second", email="owner@example.com")
|
||||
session.add_all([first, second])
|
||||
session.commit()
|
||||
owner_ids = {first.id, second.id}
|
||||
repository = SQLAlchemyAccountRepository(sqlite_session_factory)
|
||||
gateway = create_autospec(WorkspaceProvisioningStore, instance=True)
|
||||
service = _service(owners=repository, provisioning=gateway)
|
||||
service.create(name="Test", owner_email="owner@example.com")
|
||||
assert gateway.provision.call_args.kwargs["owner_id"] in owner_ids
|
||||
with pytest.raises(WorkspaceOwnerNotFoundError):
|
||||
service.create(name="Test", owner_email="OWNER@example.com")
|
||||
assert gateway.provision.call_count == 1
|
||||
|
||||
|
||||
@pytest.mark.parametrize("role", ["owner", "unknown", "ADMIN"])
|
||||
def test_invalid_roles_are_rejected_before_writes(role: str) -> None:
|
||||
gateway = create_autospec(WorkspaceProvisioningStore, instance=True)
|
||||
service = _service(owners=create_autospec(WorkspaceOwnerQuery, instance=True), provisioning=gateway)
|
||||
with pytest.raises(InvalidWorkspaceMemberRoleError):
|
||||
service.join_member(
|
||||
workspace_id="w", account_id="a", email="a@example.com", role=role, operator_account_id=None
|
||||
)
|
||||
cast(Mock, service._members).join_member.assert_not_called()
|
||||
|
||||
|
||||
def test_member_operator_is_forwarded() -> None:
|
||||
gateway = create_autospec(WorkspaceProvisioningStore, instance=True)
|
||||
service = _service(owners=create_autospec(WorkspaceOwnerQuery, instance=True), provisioning=gateway)
|
||||
service.join_member(
|
||||
workspace_id="w", account_id="a", email="a@example.com", role="editor", operator_account_id="operator"
|
||||
)
|
||||
cast(Mock, service._members).join_member.assert_called_once_with(
|
||||
workspace_id="w",
|
||||
account_id="a",
|
||||
email="a@example.com",
|
||||
role=TenantAccountRole.EDITOR,
|
||||
operator_account_id="operator",
|
||||
)
|
||||
|
||||
|
||||
def test_missing_owner_is_rejected_before_creation() -> None:
|
||||
owners = create_autospec(WorkspaceOwnerQuery, instance=True)
|
||||
owners.find_first_by_email.return_value = None
|
||||
gateway = create_autospec(WorkspaceProvisioningStore, instance=True)
|
||||
service = _service(owners=owners, provisioning=gateway)
|
||||
with pytest.raises(WorkspaceOwnerNotFoundError):
|
||||
service.create(name="Test", owner_email="owner@example.com")
|
||||
gateway.provision.assert_not_called()
|
||||
|
||||
|
||||
@pytest.mark.parametrize("owner_email", [None, "owner@example.com"])
|
||||
def test_create_delegation(owner_email: str | None) -> None:
|
||||
owners = create_autospec(WorkspaceOwnerQuery, instance=True)
|
||||
owners.find_first_by_email.return_value = OWNER
|
||||
gateway = create_autospec(WorkspaceProvisioningStore, instance=True)
|
||||
result = CreatedWorkspace("w", "Test", "sandbox", "normal", None, None, None, {})
|
||||
gateway.provision.return_value = result
|
||||
service = _service(owners=owners, provisioning=gateway)
|
||||
assert service.create(name="Test", owner_email=owner_email) is result
|
||||
assert gateway.provision.call_args.kwargs["owner_id"] == (OWNER.id if owner_email else None)
|
||||
if owner_email is None:
|
||||
owners.find_first_by_email.assert_not_called()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def gateway(
|
||||
sqlite_session_factory: sessionmaker[Session],
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
config_overrides: Callable[..., None],
|
||||
) -> tuple[WorkspaceProvisioningService, Signal]:
|
||||
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY, RBAC_ENABLED=False)
|
||||
monkeypatch.setattr(gateways.SystemFeatureService, "is_workspace_creation_allowed", lambda: True)
|
||||
monkeypatch.setattr(gateways.SystemFeatureService, "get_license", lambda: LicenseModel())
|
||||
monkeypatch.setattr(gateways, "generate_key_pair", lambda _workspace_id: "public-key")
|
||||
signal = Signal()
|
||||
monkeypatch.setattr(gateways, "tenant_was_created", signal)
|
||||
return _service(
|
||||
owners=SQLAlchemyAccountRepository(sqlite_session_factory),
|
||||
provisioning=WorkspaceRepository(sqlite_session_factory),
|
||||
effects=WorkspaceProvisioningEffectsGateway(),
|
||||
), signal
|
||||
|
||||
|
||||
@pytest.mark.parametrize("with_owner", [False, True])
|
||||
def test_creation_reuses_defaults_and_emits_one_event(
|
||||
gateway: tuple[WorkspaceProvisioningService, Signal],
|
||||
sqlite_session_factory: sessionmaker[Session],
|
||||
with_owner: bool,
|
||||
config_overrides: Callable[..., None],
|
||||
) -> None:
|
||||
adapter, signal = gateway
|
||||
config_overrides(HOSTED_POOL_CREDITS=123)
|
||||
with sqlite_session_factory() as session:
|
||||
account = Account(name="Owner", email="owner@example.com")
|
||||
session.add(account)
|
||||
session.commit()
|
||||
account_id = account.id
|
||||
emitted = []
|
||||
|
||||
def record(tenant: CreatedWorkspace) -> None:
|
||||
with sqlite_session_factory() as session:
|
||||
assert session.get(Tenant, tenant.id) is not None
|
||||
emitted.append(tenant.id)
|
||||
|
||||
signal.connect(record)
|
||||
result = adapter.create(name="Created", owner_email="owner@example.com" if with_owner else None)
|
||||
assert result.name == "Created"
|
||||
assert result.encrypt_public_key == "public-key"
|
||||
assert emitted == [result.id]
|
||||
with sqlite_session_factory() as session:
|
||||
tenant = session.get(Tenant, result.id)
|
||||
assert tenant is not None
|
||||
assert tenant.name == "Created"
|
||||
pool = session.scalar(select(TenantCreditPool).where(TenantCreditPool.tenant_id == result.id))
|
||||
assert pool is not None
|
||||
assert pool.quota_limit == 123
|
||||
assert pool.quota_used == 0
|
||||
assert pool.pool_type == "trial"
|
||||
strategies = session.scalars(
|
||||
select(TenantPluginAutoUpgradeStrategy).where(TenantPluginAutoUpgradeStrategy.tenant_id == result.id)
|
||||
).all()
|
||||
assert len(strategies) == len(gateways.TenantPluginAutoUpgradeCategory)
|
||||
for strategy in strategies:
|
||||
assert strategy.strategy_setting == gateways.PluginAutoUpgradeService.default_strategy_setting_for_category(
|
||||
strategy.category
|
||||
)
|
||||
assert strategy.upgrade_time_of_day == gateways.PluginAutoUpgradeService.default_upgrade_time_of_day(
|
||||
result.id
|
||||
)
|
||||
membership = session.scalar(select(TenantAccountJoin).where(TenantAccountJoin.tenant_id == result.id))
|
||||
if with_owner:
|
||||
assert membership is not None
|
||||
assert membership.account_id == account_id
|
||||
assert membership.role == TenantAccountRole.OWNER
|
||||
else:
|
||||
assert membership is None
|
||||
|
||||
|
||||
def test_missing_owner_cannot_create_or_emit(
|
||||
gateway: tuple[WorkspaceProvisioningService, Signal], sqlite_session_factory: sessionmaker[Session]
|
||||
) -> None:
|
||||
adapter, signal = gateway
|
||||
emitted = []
|
||||
|
||||
def record(tenant: CreatedWorkspace) -> None:
|
||||
emitted.append(tenant.id)
|
||||
|
||||
signal.connect(record)
|
||||
with pytest.raises(WorkspaceOwnerNotFoundError):
|
||||
adapter.create(name="Absent", owner_email="missing@example.com")
|
||||
with sqlite_session_factory() as session:
|
||||
assert session.scalar(select(Tenant.id)) is None
|
||||
assert emitted == []
|
||||
|
||||
|
||||
def test_membership_uses_explicit_session_and_preserves_current(
|
||||
account_domain: AccountDomain,
|
||||
sqlite_session_factory: sessionmaker[Session],
|
||||
) -> None:
|
||||
adapter = account_domain.members
|
||||
with sqlite_session_factory() as session:
|
||||
account = Account(name="Member", email="member@example.com")
|
||||
tenant = Tenant(name="Target")
|
||||
session.add_all([account, tenant])
|
||||
session.commit()
|
||||
account_id, workspace_id = (account.id, tenant.id)
|
||||
for role in (TenantAccountRole.NORMAL, TenantAccountRole.EDITOR):
|
||||
result = adapter.join_member(
|
||||
workspace_id=workspace_id,
|
||||
account_id=account_id,
|
||||
email="member@example.com",
|
||||
role=role,
|
||||
operator_account_id=None,
|
||||
)
|
||||
assert result.role == role.value
|
||||
with sqlite_session_factory() as session:
|
||||
membership = session.scalar(select(TenantAccountJoin))
|
||||
assert membership is not None
|
||||
assert membership.role == TenantAccountRole.EDITOR
|
||||
assert not membership.current
|
||||
with pytest.raises(AccountNotFoundError):
|
||||
adapter.join_member(
|
||||
workspace_id=workspace_id,
|
||||
account_id=account_id,
|
||||
email="wrong@example.com",
|
||||
role=TenantAccountRole.NORMAL,
|
||||
operator_account_id=None,
|
||||
)
|
||||
with pytest.raises(WorkspaceNotFoundError):
|
||||
adapter.join_member(
|
||||
workspace_id="absent",
|
||||
account_id=account_id,
|
||||
email="member@example.com",
|
||||
role=TenantAccountRole.NORMAL,
|
||||
operator_account_id=None,
|
||||
)
|
||||
|
||||
|
||||
def test_provisioning_rolls_back_the_entire_aggregate_when_defaults_fail(
|
||||
account_domain: AccountDomain, sqlite_session_factory: sessionmaker[Session], monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
emitted: list[str] = []
|
||||
signal = Signal()
|
||||
monkeypatch.setattr(gateways, "tenant_was_created", signal)
|
||||
|
||||
def record(tenant: CreatedWorkspace) -> None:
|
||||
emitted.append(tenant.id)
|
||||
|
||||
def reject_pool(_mapper: Mapper[TenantCreditPool], _connection: Connection, _pool: TenantCreditPool) -> None:
|
||||
raise RuntimeError("Pool write failed")
|
||||
|
||||
signal.connect(record)
|
||||
event.listen(TenantCreditPool, "before_insert", reject_pool)
|
||||
try:
|
||||
with pytest.raises(RuntimeError, match="Pool write failed"):
|
||||
account_domain.provisioning.create_with_owner_workspace(
|
||||
email="new@example.com", name="New", interface_language="en-US", timezone="UTC", ip_address="127.0.0.1"
|
||||
)
|
||||
finally:
|
||||
event.remove(TenantCreditPool, "before_insert", reject_pool)
|
||||
|
||||
with sqlite_session_factory() as session:
|
||||
for model in (Account, Tenant, TenantAccountJoin, TenantPluginAutoUpgradeStrategy, TenantCreditPool):
|
||||
assert session.scalar(select(model.id)) is None
|
||||
assert emitted == []
|
||||
|
||||
|
||||
def test_initial_workspace_creation_is_idempotent(
|
||||
account_domain: AccountDomain, sqlite_session_factory: sessionmaker[Session]
|
||||
) -> None:
|
||||
account = account_domain.accounts.create_account("owner@example.com", "Owner", "en-US")
|
||||
account_domain.provisioning.ensure_owner_workspace(account.id)
|
||||
account_domain.provisioning.ensure_owner_workspace(account.id)
|
||||
|
||||
with sqlite_session_factory() as session:
|
||||
assert len(session.scalars(select(Tenant.id)).all()) == 1
|
||||
assert len(session.scalars(select(TenantCreditPool.id)).all()) == 1
|
||||
|
||||
|
||||
def test_competing_initial_workspace_skips_key_and_owner_binding(
|
||||
account_domain: AccountDomain, sqlite_session_factory: sessionmaker[Session], monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
account = account_domain.accounts.create_account("owner@example.com", "Owner", "en-US")
|
||||
effects = create_autospec(WorkspaceProvisioningEffects, instance=True)
|
||||
effects.prepare.side_effect = [
|
||||
WorkspaceCreation("winner", "Owner's Workspace", "winner-key", 123, 0, {}),
|
||||
WorkspaceCreation("skipped", "Owner's Workspace", "orphan-key", 123, 0, {}),
|
||||
]
|
||||
monkeypatch.setattr(account_domain.provisioning, "_effects", effects)
|
||||
competing_repository = WorkspaceRepository(sqlite_session_factory)
|
||||
competing_service = WorkspaceProvisioningService(
|
||||
owners=account_domain.repository,
|
||||
provisioning=competing_repository,
|
||||
effects=effects,
|
||||
policies=account_domain.policy,
|
||||
memberships=competing_repository,
|
||||
members=account_domain.members,
|
||||
)
|
||||
has_active_workspace = account_domain.workspaces.has_active_for_account
|
||||
|
||||
def finish_competing_request_after_precheck(account_id: str) -> bool:
|
||||
# Both requests see no workspace. The winner commits before the losing
|
||||
# request reaches its locked recheck in the real repository.
|
||||
observed = has_active_workspace(account_id)
|
||||
assert not observed
|
||||
competing_service.ensure_owner_workspace(account_id)
|
||||
return observed
|
||||
|
||||
monkeypatch.setattr(account_domain.workspaces, "has_active_for_account", finish_competing_request_after_precheck)
|
||||
account_domain.provisioning.ensure_owner_workspace(account.id)
|
||||
|
||||
effects.prepare.assert_called_once_with("Owner's Workspace")
|
||||
effects.bind_owner.assert_called_once_with("winner", account.id)
|
||||
effects.created.assert_called_once()
|
||||
with sqlite_session_factory() as session:
|
||||
assert list(session.scalars(select(Tenant.id))) == ["winner"]
|
||||
assert list(session.scalars(select(TenantAccountJoin.tenant_id))) == ["winner"]
|
||||
assert list(session.scalars(select(TenantCreditPool.tenant_id))) == ["winner"]
|
||||
|
||||
|
||||
def test_initial_workspace_locks_before_preparation_and_publishes_after_commit(
|
||||
account_domain: AccountDomain, sqlite_session_factory: sessionmaker[Session], monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
account = account_domain.accounts.create_account("owner@example.com", "Owner", "en-US")
|
||||
phases: list[str] = []
|
||||
effects = create_autospec(WorkspaceProvisioningEffects, instance=True)
|
||||
|
||||
def record_lock(execution: ORMExecuteState) -> None:
|
||||
# SQLite exercises persistence; compile the actual ORM statement for
|
||||
# PostgreSQL to verify the row-lock clause that SQLite cannot execute.
|
||||
statement = execution.statement
|
||||
if isinstance(statement, Select) and "FOR UPDATE" in str(statement.compile(dialect=postgresql.dialect())):
|
||||
phases.append("lock")
|
||||
|
||||
def prepare(_name: str) -> WorkspaceCreation:
|
||||
phases.append("prepare")
|
||||
return WorkspaceCreation("workspace", "Owner's Workspace", "key", 123, 0, {})
|
||||
|
||||
def bind_owner(_workspace_id: str, _account_id: str) -> None:
|
||||
phases.append("bind")
|
||||
|
||||
def committed(_session: Session) -> None:
|
||||
phases.append("commit")
|
||||
|
||||
def published(_workspace: CreatedWorkspace, *, owner_id: str | None) -> None:
|
||||
assert owner_id == account.id
|
||||
phases.append("publish")
|
||||
|
||||
effects.prepare.side_effect = prepare
|
||||
effects.bind_owner.side_effect = bind_owner
|
||||
effects.created.side_effect = published
|
||||
monkeypatch.setattr(account_domain.provisioning, "_effects", effects)
|
||||
event.listen(sqlite_session_factory, "do_orm_execute", record_lock)
|
||||
event.listen(sqlite_session_factory, "after_commit", committed)
|
||||
try:
|
||||
account_domain.provisioning.ensure_owner_workspace(account.id)
|
||||
finally:
|
||||
event.remove(sqlite_session_factory, "do_orm_execute", record_lock)
|
||||
event.remove(sqlite_session_factory, "after_commit", committed)
|
||||
|
||||
assert phases == ["lock", "prepare", "bind", "commit", "publish"]
|
||||
|
||||
|
||||
def _service(
|
||||
*,
|
||||
owners: WorkspaceOwnerQuery,
|
||||
provisioning: WorkspaceProvisioningStore,
|
||||
effects: WorkspaceProvisioningEffects | None = None,
|
||||
) -> WorkspaceProvisioningService:
|
||||
"""Use the supplied effects, or prepare autospecced effects when omitted or None."""
|
||||
policy = create_autospec(WorkspaceCreationPolicy, instance=True)
|
||||
policy.has_workspace_capacity.return_value = True
|
||||
if effects is None:
|
||||
prepared = create_autospec(WorkspaceProvisioningEffects, instance=True)
|
||||
prepared.prepare.return_value = WorkspaceCreation("w", "Test", "key", 123, 0, {})
|
||||
effects = cast(WorkspaceProvisioningEffects, prepared)
|
||||
return WorkspaceProvisioningService(
|
||||
effects=effects,
|
||||
owners=owners,
|
||||
provisioning=provisioning,
|
||||
policies=policy,
|
||||
memberships=create_autospec(WorkspaceMembershipQuery, instance=True),
|
||||
members=create_autospec(WorkspaceMemberWriter, instance=True),
|
||||
)
|
||||
+315
@@ -0,0 +1,315 @@
|
||||
from unittest.mock import Mock
|
||||
|
||||
import pytest
|
||||
from flask import Flask
|
||||
from sqlalchemy.orm import Session, sessionmaker
|
||||
|
||||
from models import Dataset
|
||||
from models.agent import Agent, AgentHomeSnapshot, AgentScope, AgentSource, AgentStatus, AgentWorkingResourceStatus
|
||||
from repositories.app.console_repository import ConsoleAppRepository
|
||||
from repositories.knowledge.dataset_repository import SQLAlchemyDatasetRepository
|
||||
from repositories.workspace.resource_cleanup_repository import WorkspaceResourceCleanupRepository
|
||||
from services.workspace import resource_cleanup_service as module
|
||||
|
||||
|
||||
def _service(session_factory: sessionmaker[Session]) -> module.WorkspaceResourceCleanupService:
|
||||
return module.WorkspaceResourceCleanupService(
|
||||
session_factory=session_factory,
|
||||
apps=ConsoleAppRepository(session_factory=session_factory),
|
||||
datasets=SQLAlchemyDatasetRepository(session_factory=session_factory),
|
||||
agent_resources=WorkspaceResourceCleanupRepository(session_factory=session_factory),
|
||||
)
|
||||
|
||||
|
||||
def test_agent_sweep_covers_all_scopes_and_retains_other_tenants(
|
||||
sqlite_session: Session, sqlite_session_factory: sessionmaker[Session], monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
agents = [
|
||||
Agent(
|
||||
id="roster",
|
||||
tenant_id="target",
|
||||
name="Roster",
|
||||
scope=AgentScope.ROSTER,
|
||||
source=AgentSource.WORKFLOW,
|
||||
backing_app_id="missing-app",
|
||||
),
|
||||
Agent(
|
||||
id="inline", tenant_id="target", name="Inline", scope=AgentScope.WORKFLOW_ONLY, source=AgentSource.WORKFLOW
|
||||
),
|
||||
Agent(
|
||||
id="archived",
|
||||
tenant_id="target",
|
||||
name="Archived",
|
||||
scope=AgentScope.ROSTER,
|
||||
source=AgentSource.WORKFLOW,
|
||||
status=AgentStatus.ARCHIVED,
|
||||
),
|
||||
Agent(id="other", tenant_id="other-tenant", name="Other", scope=AgentScope.ROSTER, source=AgentSource.WORKFLOW),
|
||||
]
|
||||
snapshot = AgentHomeSnapshot(id="home", tenant_id="target", agent_id="inline", snapshot_ref="backend-home")
|
||||
sqlite_session.add_all([*agents, snapshot])
|
||||
sqlite_session.commit()
|
||||
collection = Mock()
|
||||
app_cleanup = Mock()
|
||||
monkeypatch.setattr(module, "enqueue_agent_resource_collection", collection)
|
||||
monkeypatch.setattr(module, "remove_app_and_related_data_task", app_cleanup)
|
||||
|
||||
def assert_committed(**_kwargs: object) -> None:
|
||||
sqlite_session.expire_all()
|
||||
inline_agent = sqlite_session.get(Agent, "inline")
|
||||
assert inline_agent is not None
|
||||
assert inline_agent.status == AgentStatus.ARCHIVED
|
||||
home_snapshot = sqlite_session.get(AgentHomeSnapshot, "home")
|
||||
assert home_snapshot is not None
|
||||
assert home_snapshot.status == AgentWorkingResourceStatus.RETIRED
|
||||
|
||||
collection.side_effect = assert_committed
|
||||
_service(sqlite_session_factory)._retire_agents("target")
|
||||
payload = collection.call_args.kwargs
|
||||
assert set(payload["purge_agent_ids"]) == {"roster", "inline", "archived"}
|
||||
assert payload["home_snapshot_ids"] == ["home"]
|
||||
other_agent = sqlite_session.get(Agent, "other")
|
||||
assert other_agent is not None
|
||||
assert other_agent.status == AgentStatus.ACTIVE
|
||||
app_cleanup.delay.assert_called_once_with(tenant_id="target", app_id="missing-app")
|
||||
|
||||
|
||||
def test_dataset_deletion_schedules_even_without_index_configuration(
|
||||
sqlite_session: Session, sqlite_session_factory: sessionmaker[Session], monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
sqlite_session.add_all(
|
||||
[
|
||||
Dataset(id="dataset", tenant_id="target", name="Empty", created_by="owner"),
|
||||
Dataset(id="other-dataset", tenant_id="other", name="Other", created_by="owner"),
|
||||
]
|
||||
)
|
||||
sqlite_session.commit()
|
||||
cleanup = Mock()
|
||||
monkeypatch.setattr(module, "clean_dataset_task", cleanup)
|
||||
monkeypatch.setattr(module.dataset_api_key_bindings, "delete_keys_scoped_only_to", Mock())
|
||||
monkeypatch.setattr(module, "build_resource_access_token_cleanup_service", Mock())
|
||||
_service(sqlite_session_factory)._delete_dataset("target", "other-dataset")
|
||||
cleanup.delay.assert_not_called()
|
||||
_service(sqlite_session_factory)._delete_dataset("target", "dataset")
|
||||
cleanup.delay.assert_called_once()
|
||||
assert cleanup.delay.call_args.args[:2] == ("dataset", "target")
|
||||
sqlite_session.expire_all()
|
||||
assert sqlite_session.get(Dataset, "dataset") is None
|
||||
assert sqlite_session.get(Dataset, "other-dataset") is not None
|
||||
|
||||
|
||||
def test_agent_collection_failure_propagates_and_retirement_can_be_retried(
|
||||
sqlite_session: Session, sqlite_session_factory: sessionmaker[Session], monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
sqlite_session.add(
|
||||
Agent(id="agent", tenant_id="target", name="Agent", scope=AgentScope.ROSTER, source=AgentSource.WORKFLOW)
|
||||
)
|
||||
sqlite_session.commit()
|
||||
collection = Mock(side_effect=RuntimeError("broker unavailable"))
|
||||
monkeypatch.setattr(module, "enqueue_agent_resource_collection", collection)
|
||||
with pytest.raises(RuntimeError, match="broker unavailable"):
|
||||
_service(sqlite_session_factory)._retire_agents("target")
|
||||
collection.side_effect = None
|
||||
_service(sqlite_session_factory)._retire_agents("target")
|
||||
assert collection.call_args.kwargs["purge_agent_ids"] == ["agent"]
|
||||
|
||||
|
||||
def test_working_resources_are_retired_even_when_the_app_is_missing(
|
||||
sqlite_session: Session, sqlite_session_factory: sessionmaker[Session], monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
from models.agent import (
|
||||
AgentConfigVersionKind,
|
||||
AgentWorkspace,
|
||||
AgentWorkspaceBinding,
|
||||
AgentWorkspaceOwnerType,
|
||||
)
|
||||
|
||||
workspace = AgentWorkspace(
|
||||
id="working",
|
||||
tenant_id="target",
|
||||
app_id="missing-app",
|
||||
owner_type=AgentWorkspaceOwnerType.CONVERSATION,
|
||||
owner_id="conversation",
|
||||
owner_scope_key="conversation",
|
||||
backend_workspace_ref="backend-workspace",
|
||||
)
|
||||
binding = AgentWorkspaceBinding(
|
||||
id="binding",
|
||||
tenant_id="target",
|
||||
app_id="missing-app",
|
||||
workspace_id="working",
|
||||
agent_id="missing-agent",
|
||||
agent_config_version_id="config",
|
||||
agent_config_version_kind=AgentConfigVersionKind.SNAPSHOT,
|
||||
backend_binding_ref="backend-binding",
|
||||
)
|
||||
sqlite_session.add_all([workspace, binding])
|
||||
sqlite_session.commit()
|
||||
collection = Mock()
|
||||
monkeypatch.setattr(module, "enqueue_agent_resource_collection", collection)
|
||||
_service(sqlite_session_factory)._retire_agents("target")
|
||||
sqlite_session.expire_all()
|
||||
working_workspace = sqlite_session.get(AgentWorkspace, "working")
|
||||
assert working_workspace is not None
|
||||
assert working_workspace.status == AgentWorkingResourceStatus.RETIRED
|
||||
working_binding = sqlite_session.get(AgentWorkspaceBinding, "binding")
|
||||
assert working_binding is not None
|
||||
assert working_binding.status == AgentWorkingResourceStatus.RETIRED
|
||||
assert collection.call_args.kwargs["workspace_ids"] == ["working"]
|
||||
assert collection.call_args.kwargs["binding_ids"] == ["binding"]
|
||||
|
||||
|
||||
def test_resource_failure_does_not_skip_the_other_groups(
|
||||
sqlite_session: Session, sqlite_session_factory: sessionmaker[Session], monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
from models import App
|
||||
from models.enums import AppStatus
|
||||
from models.model import AppMode
|
||||
|
||||
sqlite_session.add_all(
|
||||
[
|
||||
App(
|
||||
id="app",
|
||||
tenant_id="target",
|
||||
name="App",
|
||||
mode=AppMode.WORKFLOW,
|
||||
status=AppStatus.NORMAL,
|
||||
enable_site=True,
|
||||
enable_api=True,
|
||||
),
|
||||
Dataset(id="dataset", tenant_id="target", name="Dataset", created_by="owner"),
|
||||
]
|
||||
)
|
||||
sqlite_session.commit()
|
||||
app_service = Mock()
|
||||
app_service.return_value.delete_app.side_effect = RuntimeError("app failed")
|
||||
monkeypatch.setattr(module, "AppService", app_service)
|
||||
datasets = Mock()
|
||||
agents = Mock()
|
||||
monkeypatch.setattr(module.WorkspaceResourceCleanupService, "_delete_dataset", datasets)
|
||||
monkeypatch.setattr(module.WorkspaceResourceCleanupService, "_retire_agents", agents)
|
||||
with pytest.raises(RuntimeError, match="app:app"):
|
||||
_service(sqlite_session_factory).cleanup("target")
|
||||
datasets.assert_called_once_with("target", "dataset")
|
||||
agents.assert_called_once_with("target")
|
||||
|
||||
|
||||
def test_agent_skill_snapshots_and_orphan_homes_are_included(
|
||||
sqlite_session: Session, sqlite_session_factory: sessionmaker[Session], monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
from models.skill import AgentSkillBindingSnapshot
|
||||
|
||||
sqlite_session.add_all(
|
||||
[
|
||||
AgentHomeSnapshot(id="orphan-home", tenant_id="target", agent_id="missing", snapshot_ref="backend"),
|
||||
AgentSkillBindingSnapshot(
|
||||
id="target-binding",
|
||||
tenant_id="target",
|
||||
agent_id="missing",
|
||||
config_snapshot_id="config",
|
||||
skill_id="skill",
|
||||
priority=0,
|
||||
),
|
||||
AgentSkillBindingSnapshot(
|
||||
id="other-binding",
|
||||
tenant_id="other",
|
||||
agent_id="missing",
|
||||
config_snapshot_id="config",
|
||||
skill_id="skill",
|
||||
priority=0,
|
||||
),
|
||||
]
|
||||
)
|
||||
sqlite_session.commit()
|
||||
collection = Mock()
|
||||
monkeypatch.setattr(module, "enqueue_agent_resource_collection", collection)
|
||||
_service(sqlite_session_factory)._retire_agents("target")
|
||||
sqlite_session.expire_all()
|
||||
assert sqlite_session.get(AgentSkillBindingSnapshot, "target-binding") is None
|
||||
assert sqlite_session.get(AgentSkillBindingSnapshot, "other-binding") is not None
|
||||
orphan_home = sqlite_session.get(AgentHomeSnapshot, "orphan-home")
|
||||
assert orphan_home is not None
|
||||
assert orphan_home.status == AgentWorkingResourceStatus.RETIRED
|
||||
assert collection.call_args.kwargs["home_snapshot_ids"] == ["orphan-home"]
|
||||
|
||||
|
||||
def test_direct_cleanup_does_not_resolve_a_console_login(
|
||||
app: Flask,
|
||||
sqlite_session: Session,
|
||||
sqlite_session_factory: sessionmaker[Session],
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
from unittest.mock import MagicMock
|
||||
|
||||
from models import App
|
||||
from models.enums import AppStatus
|
||||
from models.model import AppMode
|
||||
from services import app_service
|
||||
|
||||
sqlite_session.add(
|
||||
App(
|
||||
id="app",
|
||||
tenant_id="target",
|
||||
name="App",
|
||||
mode=AppMode.WORKFLOW,
|
||||
status=AppStatus.NORMAL,
|
||||
enable_site=True,
|
||||
enable_api=True,
|
||||
)
|
||||
)
|
||||
sqlite_session.commit()
|
||||
user = MagicMock()
|
||||
user.__bool__.side_effect = AssertionError("inner API must not load a console user")
|
||||
monkeypatch.setattr(app_service, "current_user", user)
|
||||
monkeypatch.setattr(app_service.app_was_deleted, "send", Mock())
|
||||
monkeypatch.setattr(app_service, "build_resource_access_token_cleanup_service", Mock())
|
||||
monkeypatch.setattr(app_service, "remove_app_and_related_data_task", Mock())
|
||||
retirement = Mock()
|
||||
monkeypatch.setattr(app_service, "WorkflowAgentRetirementService", retirement)
|
||||
monkeypatch.setattr(app_service, "enqueue_agent_resource_collection", Mock())
|
||||
features = Mock()
|
||||
features.is_webapp_auth_enabled.return_value = False
|
||||
monkeypatch.setattr(app_service, "SystemFeatureService", features)
|
||||
monkeypatch.setattr(app_service, "BillingService", Mock())
|
||||
monkeypatch.setattr(module, "enqueue_agent_resource_collection", Mock())
|
||||
with app.test_request_context(method="DELETE"):
|
||||
_service(sqlite_session_factory).cleanup("target")
|
||||
sqlite_session.expire_all()
|
||||
assert sqlite_session.get(App, "app") is None
|
||||
assert retirement.retire_unowned.call_args.kwargs["account_id"] is None
|
||||
user.__bool__.assert_not_called()
|
||||
|
||||
|
||||
def test_tenant_home_snapshot_retirement_is_tenant_scoped_and_idempotent(sqlite_session: Session) -> None:
|
||||
from datetime import datetime
|
||||
|
||||
from services.agent.home_snapshot_service import AgentHomeSnapshotService
|
||||
|
||||
retired_at = datetime(2026, 1, 1)
|
||||
sqlite_session.add_all(
|
||||
[
|
||||
AgentHomeSnapshot(id="active", tenant_id="target", agent_id="agent", snapshot_ref="a"),
|
||||
AgentHomeSnapshot(
|
||||
id="retired",
|
||||
tenant_id="target",
|
||||
agent_id="missing",
|
||||
snapshot_ref="b",
|
||||
status=AgentWorkingResourceStatus.RETIRED,
|
||||
retired_at=retired_at,
|
||||
),
|
||||
AgentHomeSnapshot(id="other", tenant_id="other", agent_id="agent", snapshot_ref="c"),
|
||||
]
|
||||
)
|
||||
sqlite_session.commit()
|
||||
ids = AgentHomeSnapshotService.retire_all_for_tenant(session=sqlite_session, tenant_id="target")
|
||||
sqlite_session.commit()
|
||||
assert set(ids) == {"active", "retired"}
|
||||
active = sqlite_session.get(AgentHomeSnapshot, "active")
|
||||
retired = sqlite_session.get(AgentHomeSnapshot, "retired")
|
||||
other = sqlite_session.get(AgentHomeSnapshot, "other")
|
||||
assert active is not None
|
||||
assert active.status == AgentWorkingResourceStatus.RETIRED
|
||||
assert retired is not None
|
||||
assert retired.retired_at == retired_at
|
||||
assert other is not None
|
||||
assert other.status == AgentWorkingResourceStatus.ACTIVE
|
||||
@@ -0,0 +1,150 @@
|
||||
"""Workspace orchestration without Flask or ORM dependencies."""
|
||||
|
||||
from dataclasses import replace
|
||||
from datetime import datetime
|
||||
from unittest.mock import Mock, create_autospec
|
||||
|
||||
import pytest
|
||||
|
||||
from enums import CloudPlan
|
||||
from machinery.context import RequestContext
|
||||
from services.errors.file import UnsupportedFileTypeError
|
||||
from services.errors.workspace import WorkspaceArchivedError, WorkspaceNotFoundError
|
||||
from services.workspace.contracts import (
|
||||
EffectiveCreditPool,
|
||||
WorkspaceCustomConfig,
|
||||
WorkspaceCustomConfigChanges,
|
||||
WorkspaceFeatures,
|
||||
WorkspaceSnapshot,
|
||||
)
|
||||
from services.workspace.service import (
|
||||
WorkspaceFeatureGateway,
|
||||
WorkspaceLogoGateway,
|
||||
WorkspaceService,
|
||||
WorkspaceStore,
|
||||
)
|
||||
|
||||
CONTEXT = RequestContext("request", None, "account", "workspace")
|
||||
WORKSPACE = WorkspaceSnapshot(
|
||||
"workspace", "Test", "normal", datetime(2026, 1, 1), "editor", WorkspaceCustomConfig(True, "stored-logo"), True
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def dependencies() -> tuple[WorkspaceService, Mock, Mock, Mock]:
|
||||
store = create_autospec(WorkspaceStore, instance=True)
|
||||
features = create_autospec(WorkspaceFeatureGateway, instance=True)
|
||||
logos = create_autospec(WorkspaceLogoGateway, instance=True)
|
||||
store.get_for_account.return_value = WORKSPACE
|
||||
features.logo_url.return_value = "https://files/workspaces/workspace/webapp-logo"
|
||||
features.get_features.return_value = WorkspaceFeatures(True, EffectiveCreditPool())
|
||||
return (WorkspaceService(workspaces=store, features=features, logos=logos), store, features, logos)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("plan", "limit", "used", "remaining"),
|
||||
[
|
||||
(CloudPlan.SANDBOX, 100, 30, 70),
|
||||
(CloudPlan.TEAM, -1, 999, -1),
|
||||
(CloudPlan.TEAM, 10, 20, 0),
|
||||
(None, None, None, None),
|
||||
],
|
||||
)
|
||||
def test_summary_uses_context_identity_and_credit_snapshot(
|
||||
dependencies: tuple[WorkspaceService, Mock, Mock, Mock],
|
||||
plan: CloudPlan | None,
|
||||
limit: int | None,
|
||||
used: int | None,
|
||||
remaining: int | None,
|
||||
) -> None:
|
||||
service, store, features, _ = dependencies
|
||||
features.get_effective_credit_pool.return_value = EffectiveCreditPool(plan=plan, quota_limit=limit, quota_used=used)
|
||||
assert service.current_summary(CONTEXT) == {
|
||||
"id": "workspace",
|
||||
"name": "Test",
|
||||
"role": "editor",
|
||||
"plan": plan,
|
||||
"credits": remaining,
|
||||
}
|
||||
store.get_for_account.assert_called_once_with("workspace", "account")
|
||||
|
||||
|
||||
def test_archived_workspace_does_not_read_billing(dependencies: tuple[WorkspaceService, Mock, Mock, Mock]) -> None:
|
||||
service, store, features, _ = dependencies
|
||||
store.get_for_account.return_value = replace(WORKSPACE, status="archive")
|
||||
with pytest.raises(WorkspaceArchivedError):
|
||||
service.current_summary(CONTEXT)
|
||||
features.get_effective_credit_pool.assert_not_called()
|
||||
|
||||
|
||||
def test_missing_workspace(dependencies: tuple[WorkspaceService, Mock, Mock, Mock]) -> None:
|
||||
service, store, _, _ = dependencies
|
||||
store.get_for_account.return_value = None
|
||||
with pytest.raises(WorkspaceNotFoundError):
|
||||
service.custom_config(CONTEXT)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("changes", "expected"),
|
||||
[
|
||||
(WorkspaceCustomConfigChanges(None, None), WorkspaceCustomConfig(True, "stored-logo")),
|
||||
(WorkspaceCustomConfigChanges(False, None), WorkspaceCustomConfig(False, "stored-logo")),
|
||||
(WorkspaceCustomConfigChanges(None, ""), WorkspaceCustomConfig(True, "")),
|
||||
(WorkspaceCustomConfigChanges(None, "new-logo"), WorkspaceCustomConfig(True, "new-logo")),
|
||||
],
|
||||
)
|
||||
def test_config_patch_preserves_omitted_fields_and_honors_false_and_empty(
|
||||
dependencies: tuple[WorkspaceService, Mock, Mock, Mock],
|
||||
changes: WorkspaceCustomConfigChanges,
|
||||
expected: WorkspaceCustomConfig,
|
||||
) -> None:
|
||||
service, store, _, _ = dependencies
|
||||
store.update_custom_config.return_value = replace(WORKSPACE, custom_config=expected)
|
||||
service.update_custom_config(CONTEXT, changes)
|
||||
store.update_custom_config.assert_called_once_with(workspace_id="workspace", account_id="account", changes=expected)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("can_replace", "has_manager", "includes_config"), [(True, True, True), (True, False, False), (False, True, False)]
|
||||
)
|
||||
def test_tenant_info_preserves_workspace_brand_visibility(
|
||||
dependencies: tuple[WorkspaceService, Mock, Mock, Mock], can_replace: bool, has_manager: bool, includes_config: bool
|
||||
) -> None:
|
||||
service, store, features, _ = dependencies
|
||||
store.rename.return_value = replace(WORKSPACE, has_privileged_member=has_manager)
|
||||
features.get_features.return_value = WorkspaceFeatures(can_replace, EffectiveCreditPool())
|
||||
result = service.rename(CONTEXT, "New")
|
||||
assert ("custom_config" in result) is includes_config
|
||||
assert result["plan"] is None
|
||||
assert "trial_credits" not in result
|
||||
|
||||
|
||||
def test_switch_serializes_effective_exhausted_pool(dependencies: tuple[WorkspaceService, Mock, Mock, Mock]) -> None:
|
||||
service, store, features, _ = dependencies
|
||||
store.switch.return_value = WORKSPACE
|
||||
features.get_features.return_value = WorkspaceFeatures(
|
||||
True, EffectiveCreditPool(CloudPlan.TEAM, "trial", 100, 100, 1770000000, 1780000000)
|
||||
)
|
||||
result = service.switch(CONTEXT, "target")
|
||||
assert result["trial_credits"] == 100
|
||||
assert result["trial_credits_used"] == 100
|
||||
assert result["trial_credits_exhausted_at"] == 1770000000
|
||||
assert result["next_credit_reset_date"] == 1780000000
|
||||
store.switch.assert_called_once_with(account_id="account", workspace_id="target")
|
||||
|
||||
|
||||
@pytest.mark.parametrize("filename", ["logo.jpg", "file.txt", "logo"])
|
||||
def test_invalid_logo_never_reaches_storage(
|
||||
dependencies: tuple[WorkspaceService, Mock, Mock, Mock], filename: str
|
||||
) -> None:
|
||||
service, _, _, logos = dependencies
|
||||
with pytest.raises(UnsupportedFileTypeError):
|
||||
service.upload_logo(CONTEXT, filename=filename, content=b"data", mimetype="image/jpeg")
|
||||
logos.upload.assert_not_called()
|
||||
|
||||
|
||||
def test_logo_delegation(dependencies: tuple[WorkspaceService, Mock, Mock, Mock]) -> None:
|
||||
service, _, _, logos = dependencies
|
||||
logos.upload.return_value = "file-id"
|
||||
assert service.upload_logo(CONTEXT, filename="logo.SVG", content=b"<svg/>", mimetype="image/svg+xml") == "file-id"
|
||||
logos.upload.assert_called_once_with(CONTEXT, filename="logo.SVG", content=b"<svg/>", mimetype="image/svg+xml")
|
||||
Reference in new issue
Block a user