chore: 纳入本地 Dify 1.19.0 源码及品牌与免登改动

演示目录只保留可重建的源码。运行密钥、数据卷、依赖和带口令的本地配置不进入仓库。

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
wuzilongandCursor committed 2026-11-18 13:59:25 +08:00
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),
)
@@ -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")