Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

17.2 KB
Raw Blame
"""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",
    "[email protected]",
    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="[email protected]")
        second = Account(name="Second", email="[email protected]")
        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="[email protected]")
    assert gateway.provision.call_args.kwargs["owner_id"] in owner_ids
    with pytest.raises(WorkspaceOwnerNotFoundError):
        service.create(name="Test", owner_email="[email protected]")
    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="[email protected]", 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="[email protected]", role="editor", operator_account_id="operator"
    )
    cast(Mock, service._members).join_member.assert_called_once_with(
        workspace_id="w",
        account_id="a",
        email="[email protected]",
        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="[email protected]")
    gateway.provision.assert_not_called()


@pytest.mark.parametrize("owner_email", [None, "[email protected]"])
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="[email protected]")
        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="[email protected]" 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="[email protected]")
    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="[email protected]")
        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="[email protected]",
            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="[email protected]",
            role=TenantAccountRole.NORMAL,
            operator_account_id=None,
        )
    with pytest.raises(WorkspaceNotFoundError):
        adapter.join_member(
            workspace_id="absent",
            account_id=account_id,
            email="[email protected]",
            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="[email protected]", 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("[email protected]", "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("[email protected]", "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("[email protected]", "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),
    )