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.

26.5 KB
Raw Blame
from contextlib import nullcontext
from datetime import datetime, timedelta
from types import SimpleNamespace
from unittest.mock import MagicMock

import pytest
from sqlalchemy import select
from sqlalchemy.orm import Session, sessionmaker

from models.agent import (
    AgentConfigVersionKind,
    AgentHomeSnapshot,
    AgentWorkingResourceStatus,
    AgentWorkspace,
    AgentWorkspaceBinding,
    AgentWorkspaceOwnerType,
)
from services.agent.workspace_service import (
    AgentWorkspaceError,
    AgentWorkspaceNotFoundError,
    AgentWorkspaceService,
    WorkspaceOwnerScope,
)
from tests.helpers.unit.config_override import apply_config_overrides


def _scope() -> WorkspaceOwnerScope:
    return WorkspaceOwnerScope(
        tenant_id="tenant-1",
        app_id="app-1",
        owner_type=AgentWorkspaceOwnerType.CONVERSATION,
        owner_id="conversation-1",
    )


def _backend_client() -> MagicMock:
    client = MagicMock()
    client.create_execution_binding_sync.return_value = SimpleNamespace(
        binding_ref="binding-ref",
        workspace_ref="workspace-ref",
    )
    return client


def _workspace(
    *,
    workspace_id: str = "workspace-1",
    tenant_id: str = "tenant-1",
    app_id: str = "app-1",
    owner_type: AgentWorkspaceOwnerType = AgentWorkspaceOwnerType.CONVERSATION,
    owner_id: str = "conversation-1",
    owner_scope_key: str = "root",
    status: AgentWorkingResourceStatus = AgentWorkingResourceStatus.ACTIVE,
    updated_at: datetime | None = None,
    backend_workspace_ref: str = "workspace-ref",
) -> AgentWorkspace:
    row = AgentWorkspace(
        id=workspace_id,
        tenant_id=tenant_id,
        app_id=app_id,
        owner_type=owner_type,
        owner_id=owner_id,
        owner_scope_key=owner_scope_key,
        backend_workspace_ref=backend_workspace_ref,
        status=status,
        active_guard=1 if status is AgentWorkingResourceStatus.ACTIVE else None,
    )
    if updated_at is not None:
        row.updated_at = updated_at
    return row


def _binding(
    *,
    binding_id: str = "binding-1",
    tenant_id: str = "tenant-1",
    app_id: str = "app-1",
    workspace_id: str = "workspace-1",
    agent_id: str = "agent-1",
    status: AgentWorkingResourceStatus = AgentWorkingResourceStatus.ACTIVE,
    config_kind: AgentConfigVersionKind = AgentConfigVersionKind.SNAPSHOT,
    updated_at: datetime | None = None,
) -> AgentWorkspaceBinding:
    row = AgentWorkspaceBinding(
        id=binding_id,
        tenant_id=tenant_id,
        app_id=app_id,
        workspace_id=workspace_id,
        agent_id=agent_id,
        base_home_snapshot_id="home-1",
        agent_config_version_id="config-1",
        agent_config_version_kind=config_kind,
        backend_binding_ref=f"{binding_id}-ref",
        status=status,
    )
    if updated_at is not None:
        row.updated_at = updated_at
    return row


def test_workspace_client_honors_the_configured_snapshot_timeout(monkeypatch: pytest.MonkeyPatch) -> None:
    apply_config_overrides(
        monkeypatch,
        AGENT_BACKEND_BASE_URL="http://agent.example",
        AGENT_BACKEND_HOME_SNAPSHOT_TIMEOUT_SECONDS=123.5,
    )

    client = AgentWorkspaceService._client()

    assert client._timeout == 123.5


def test_create_binding_success_persists_new_workspace_and_binding(
    monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
    sqlite_session.add(
        AgentHomeSnapshot(
            id="home-1",
            tenant_id="tenant-1",
            agent_id="agent-1",
            snapshot_ref="home-ref",
            status=AgentWorkingResourceStatus.ACTIVE,
        )
    )
    sqlite_session.commit()
    client = _backend_client()
    monkeypatch.setattr(AgentWorkspaceService, "_client", lambda: nullcontext(client))

    binding = AgentWorkspaceService.create_binding(
        session=sqlite_session,
        scope=_scope(),
        agent_id="agent-1",
        base_home_snapshot_id="home-1",
        agent_config_version_id="config-1",
        agent_config_version_kind=AgentConfigVersionKind.SNAPSHOT,
    )
    sqlite_session.commit()

    workspace = sqlite_session.scalar(select(AgentWorkspace))
    stored_binding = sqlite_session.get(AgentWorkspaceBinding, binding.id)
    assert workspace is not None
    assert stored_binding is not None
    assert binding.workspace_id == workspace.id
    assert stored_binding.backend_binding_ref == "binding-ref"
    request = client.create_execution_binding_sync.call_args.args[0]
    assert request.existing_workspace_ref is None
    assert request.workspace_id == workspace.id
    assert request.home_snapshot_ref == "home-ref"


def test_create_binding_without_home_snapshot_uses_backend_default(
    monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
    client = _backend_client()
    monkeypatch.setattr(AgentWorkspaceService, "_client", lambda: nullcontext(client))

    binding = AgentWorkspaceService.create_binding(
        session=sqlite_session,
        scope=_scope(),
        agent_id="agent-1",
        base_home_snapshot_id=None,
        agent_config_version_id="config-1",
        agent_config_version_kind=AgentConfigVersionKind.SNAPSHOT,
    )
    sqlite_session.commit()

    stored_binding = sqlite_session.get(AgentWorkspaceBinding, binding.id)
    assert stored_binding is not None
    assert stored_binding.base_home_snapshot_id is None
    request = client.create_execution_binding_sync.call_args.args[0]
    assert request.home_snapshot_ref is None


def test_create_binding_rejects_missing_explicit_home_snapshot_before_backend_call(
    monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
    client = _backend_client()
    monkeypatch.setattr(AgentWorkspaceService, "_client", lambda: nullcontext(client))

    with pytest.raises(AgentWorkspaceNotFoundError, match="base Home Snapshot is unavailable"):
        AgentWorkspaceService.create_binding(
            session=sqlite_session,
            scope=_scope(),
            agent_id="agent-1",
            base_home_snapshot_id="missing-home",
            agent_config_version_id="config-1",
            agent_config_version_kind=AgentConfigVersionKind.SNAPSHOT,
        )

    client.create_execution_binding_sync.assert_not_called()


def test_create_second_binding_reuses_existing_workspace(
    monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
    workspace = _workspace()
    first_binding = _binding()
    home = AgentHomeSnapshot(
        id="home-1",
        tenant_id="tenant-1",
        agent_id="agent-1",
        snapshot_ref="home-ref",
        status=AgentWorkingResourceStatus.ACTIVE,
    )
    sqlite_session.add_all([workspace, first_binding, home])
    sqlite_session.commit()
    client = _backend_client()
    monkeypatch.setattr(AgentWorkspaceService, "_client", lambda: nullcontext(client))

    binding = AgentWorkspaceService.create_binding(
        session=sqlite_session,
        scope=_scope(),
        agent_id="agent-1",
        base_home_snapshot_id="home-1",
        agent_config_version_id="config-1",
        agent_config_version_kind=AgentConfigVersionKind.SNAPSHOT,
    )
    sqlite_session.commit()

    assert binding.workspace_id == workspace.id
    assert sqlite_session.scalars(select(AgentWorkspace)).all() == [workspace]
    assert {row.id for row in sqlite_session.scalars(select(AgentWorkspaceBinding)).all()} == {
        first_binding.id,
        binding.id,
    }
    request = client.create_execution_binding_sync.call_args.args[0]
    assert request.existing_workspace_ref == "workspace-ref"
    assert request.workspace_id == workspace.id


def test_get_active_binding_resolves_exact_participant(sqlite_session: Session) -> None:
    conversation_workspace = _workspace(workspace_id="workspace-conversation")
    build_workspace = _workspace(
        workspace_id="workspace-build",
        owner_type=AgentWorkspaceOwnerType.BUILD_DRAFT,
        owner_id="draft-1",
    )
    conversation_binding = _binding(
        binding_id="binding-conversation",
        workspace_id=conversation_workspace.id,
    )
    build_binding = _binding(
        binding_id="binding-build",
        workspace_id=build_workspace.id,
        config_kind=AgentConfigVersionKind.BUILD_DRAFT,
    )
    sqlite_session.add_all([conversation_workspace, build_workspace, conversation_binding, build_binding])
    sqlite_session.commit()

    resolved = AgentWorkspaceService.get_active_binding(
        session=sqlite_session,
        tenant_id="tenant-1",
        binding_id=conversation_binding.id,
        expected_owner_scope=_scope(),
    )

    assert resolved is not None
    assert resolved.id == conversation_binding.id


def test_get_active_binding_rejects_wrong_owner(sqlite_session: Session) -> None:
    build_workspace = _workspace(
        workspace_id="workspace-build",
        owner_type=AgentWorkspaceOwnerType.BUILD_DRAFT,
        owner_id="draft-1",
    )
    build_binding = _binding(
        binding_id="binding-build",
        workspace_id=build_workspace.id,
        config_kind=AgentConfigVersionKind.BUILD_DRAFT,
    )
    sqlite_session.add_all([build_workspace, build_binding])
    sqlite_session.commit()

    resolved = AgentWorkspaceService.get_active_binding(
        session=sqlite_session,
        tenant_id="tenant-1",
        binding_id=build_binding.id,
        expected_owner_scope=_scope(),
    )

    assert resolved is None


def test_retire_non_final_binding_keeps_workspace_active(sqlite_session: Session) -> None:
    binding = _binding()
    other_binding = _binding(binding_id="binding-2", agent_id="agent-2")
    workspace = _workspace()
    sqlite_session.add_all([workspace, binding, other_binding])
    sqlite_session.commit()

    retired_id = AgentWorkspaceService.retire_binding(
        session=sqlite_session,
        tenant_id="tenant-1",
        binding_id=binding.id,
    )

    assert retired_id == binding.id
    assert binding.status is AgentWorkingResourceStatus.RETIRED
    assert binding.retired_at is not None
    assert workspace.status is AgentWorkingResourceStatus.ACTIVE
    assert other_binding.status is AgentWorkingResourceStatus.ACTIVE


def test_retire_final_binding_retires_workspace(sqlite_session: Session) -> None:
    binding = _binding()
    workspace = _workspace()
    sqlite_session.add_all([workspace, binding])
    sqlite_session.commit()

    AgentWorkspaceService.retire_binding(session=sqlite_session, tenant_id="tenant-1", binding_id=binding.id)

    assert binding.status is AgentWorkingResourceStatus.RETIRED
    assert workspace.status is AgentWorkingResourceStatus.RETIRED
    assert workspace.active_guard is None
    assert workspace.retired_at == binding.retired_at


def test_retire_workspace_retires_all_active_bindings(sqlite_session: Session) -> None:
    workspace = _workspace()
    bindings = [_binding(), _binding(binding_id="binding-2", agent_id="agent-2")]
    sqlite_session.add_all([workspace, *bindings])
    sqlite_session.commit()

    retired_id = AgentWorkspaceService.retire_workspace(
        session=sqlite_session,
        tenant_id="tenant-1",
        workspace_id=workspace.id,
    )
    sqlite_session.flush()

    assert retired_id == workspace.id
    assert workspace.status is AgentWorkingResourceStatus.RETIRED
    assert all(binding.status is AgentWorkingResourceStatus.RETIRED for binding in bindings)
    assert all(binding.retired_at == workspace.retired_at for binding in bindings)


def test_resolve_active_binding_for_scope_returns_matching_participant(sqlite_session: Session) -> None:
    workspace = _workspace(owner_scope_key="node-1:workflow-binding-1")
    binding = _binding(binding_id="binding-chatflow", workspace_id=workspace.id)
    sqlite_session.add_all([workspace, binding])
    sqlite_session.commit()

    resolved = AgentWorkspaceService.resolve_active_binding_for_scope(
        session=sqlite_session,
        scope=WorkspaceOwnerScope(
            tenant_id="tenant-1",
            app_id="app-1",
            owner_type=AgentWorkspaceOwnerType.CONVERSATION,
            owner_id="conversation-1",
            owner_scope_key="node-1:workflow-binding-1",
        ),
        agent_id="agent-1",
    )

    assert resolved is not None
    assert resolved.id == binding.id


def test_retire_all_for_conversation_retires_only_matching_conversation_workspaces(
    sqlite_session: Session,
) -> None:
    matching = _workspace(
        workspace_id="workspace-chatflow",
        owner_scope_key="node-1:workflow-binding-1",
    )
    other_conversation = _workspace(
        workspace_id="workspace-other-conversation",
        owner_id="conversation-2",
        owner_scope_key="node-2:workflow-binding-2",
    )
    workflow_run = _workspace(
        workspace_id="workspace-workflow-run",
        owner_type=AgentWorkspaceOwnerType.WORKFLOW_RUN,
        owner_id="run-1",
        owner_scope_key="node-1:workflow-binding-1",
    )
    sqlite_session.add_all([matching, other_conversation, workflow_run])
    sqlite_session.commit()

    retired_ids = AgentWorkspaceService.retire_all_for_conversation(
        session=sqlite_session,
        tenant_id="tenant-1",
        app_id="app-1",
        conversation_id="conversation-1",
    )

    assert retired_ids == [matching.id]
    assert matching.status is AgentWorkingResourceStatus.RETIRED
    assert other_conversation.status is AgentWorkingResourceStatus.ACTIVE
    assert workflow_run.status is AgentWorkingResourceStatus.ACTIVE


def test_retire_all_for_app_retires_only_active_workspaces_for_that_app(sqlite_session: Session) -> None:
    active = _workspace(workspace_id="workspace-active", owner_id="conversation-active")
    already_retired = _workspace(
        workspace_id="workspace-retired",
        owner_id="conversation-retired",
        status=AgentWorkingResourceStatus.RETIRED,
    )
    other_app = _workspace(
        workspace_id="workspace-other",
        app_id="app-2",
        owner_id="conversation-other",
    )
    active_binding = _binding(binding_id="binding-active", workspace_id=active.id)
    other_binding = _binding(
        binding_id="binding-other",
        app_id="app-2",
        workspace_id=other_app.id,
    )
    sqlite_session.add_all([active, already_retired, other_app, active_binding, other_binding])
    sqlite_session.commit()

    retired_ids = AgentWorkspaceService.retire_all_for_app(
        session=sqlite_session,
        tenant_id="tenant-1",
        app_id="app-1",
    )

    assert retired_ids == [active.id]
    assert active.status is AgentWorkingResourceStatus.RETIRED
    assert active_binding.status is AgentWorkingResourceStatus.RETIRED
    assert already_retired.status is AgentWorkingResourceStatus.RETIRED
    assert other_app.status is AgentWorkingResourceStatus.ACTIVE
    assert other_binding.status is AgentWorkingResourceStatus.ACTIVE


def test_collect_binding_without_retired_workspace_destroys_binding_only(
    monkeypatch: pytest.MonkeyPatch,
    sqlite_session: Session,
    sqlite_session_factory: sessionmaker[Session],
) -> None:
    binding = _binding(status=AgentWorkingResourceStatus.RETIRED)
    workspace = _workspace()
    sqlite_session.add_all([workspace, binding])
    sqlite_session.commit()
    client = MagicMock()
    monkeypatch.setattr(AgentWorkspaceService, "_client", lambda: nullcontext(client))

    AgentWorkspaceService.collect_retired_binding(tenant_id="tenant-1", binding_id=binding.id)

    request = client.destroy_execution_binding_sync.call_args.args[0]
    assert request.binding_ref == binding.backend_binding_ref
    assert request.destroy_workspace is False
    assert request.workspace_ref is None
    with sqlite_session_factory() as observer:
        assert observer.get(AgentWorkspaceBinding, binding.id) is None
        assert observer.get(AgentWorkspace, workspace.id) is not None


def test_collect_workspace_destroys_workspace_then_remaining_bindings(
    monkeypatch: pytest.MonkeyPatch,
    sqlite_session: Session,
) -> None:
    workspace = _workspace(status=AgentWorkingResourceStatus.RETIRED)
    anchor = _binding(status=AgentWorkingResourceStatus.RETIRED)
    remaining = _binding(
        binding_id="binding-2",
        agent_id="agent-2",
        status=AgentWorkingResourceStatus.RETIRED,
    )
    anchor.created_at = datetime(2026, 7, 23, 10)
    remaining.created_at = anchor.created_at + timedelta(minutes=1)
    sqlite_session.add_all([workspace, anchor, remaining])
    sqlite_session.commit()
    client = MagicMock()
    commit = MagicMock(wraps=sqlite_session.commit)
    monkeypatch.setattr(
        "services.agent.workspace_service.session_factory.create_session", lambda: nullcontext(sqlite_session)
    )
    monkeypatch.setattr(sqlite_session, "commit", commit)
    monkeypatch.setattr(AgentWorkspaceService, "_client", lambda: nullcontext(client))

    AgentWorkspaceService.collect_retired_workspace(tenant_id="tenant-1", workspace_id=workspace.id)

    requests = [call.args[0] for call in client.destroy_execution_binding_sync.call_args_list]
    assert len(requests) == 2
    assert requests[0].binding_ref == anchor.backend_binding_ref
    assert requests[0].workspace_ref == workspace.backend_workspace_ref
    assert requests[0].destroy_workspace is True
    assert requests[1].binding_ref == remaining.backend_binding_ref
    assert requests[1].destroy_workspace is False
    assert sqlite_session.get(AgentWorkspace, workspace.id) is None
    assert sqlite_session.get(AgentWorkspaceBinding, anchor.id) is None
    assert sqlite_session.get(AgentWorkspaceBinding, remaining.id) is None
    commit.assert_called_once()


@pytest.mark.parametrize("sqlite_session", [(AgentWorkspace, AgentWorkspaceBinding)], indirect=True)
def test_collect_workspace_remaining_failure_preserves_ledgers_and_replay_converges(
    monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
    workspace = _workspace(status=AgentWorkingResourceStatus.RETIRED)
    anchor = _binding(status=AgentWorkingResourceStatus.RETIRED)
    remaining = [
        _binding(
            binding_id=f"binding-{index}",
            agent_id=f"agent-{index}",
            status=AgentWorkingResourceStatus.RETIRED,
        )
        for index in (2, 3)
    ]
    anchor.created_at = datetime(2026, 7, 23, 10)
    for index, binding in enumerate(remaining, start=1):
        binding.created_at = anchor.created_at + timedelta(minutes=index)
    sqlite_session.add_all([workspace, anchor, *remaining])
    sqlite_session.commit()
    workspace_id = workspace.id
    binding_ids = [anchor.id, *(binding.id for binding in remaining)]
    error = RuntimeError("middle Binding destroy failed")
    client = MagicMock()
    client.destroy_execution_binding_sync.side_effect = [None, error, None]
    monkeypatch.setattr(
        "services.agent.workspace_service.session_factory.create_session", lambda: nullcontext(sqlite_session)
    )
    monkeypatch.setattr(AgentWorkspaceService, "_client", lambda: nullcontext(client))

    with pytest.raises(RuntimeError) as exc_info:
        AgentWorkspaceService.collect_retired_workspace(tenant_id="tenant-1", workspace_id=workspace_id)

    assert exc_info.value is error
    assert client.destroy_execution_binding_sync.call_count == 3
    first_attempt = [call.args[0] for call in client.destroy_execution_binding_sync.call_args_list]
    assert [request.destroy_workspace for request in first_attempt] == [True, False, False]
    assert sqlite_session.get(AgentWorkspace, workspace_id) is not None
    assert all(sqlite_session.get(AgentWorkspaceBinding, binding_id) is not None for binding_id in binding_ids)

    client.reset_mock()
    client.destroy_execution_binding_sync.side_effect = None
    AgentWorkspaceService.collect_retired_workspace(tenant_id="tenant-1", workspace_id=workspace_id)

    assert client.destroy_execution_binding_sync.call_count == 3
    assert sqlite_session.get(AgentWorkspace, workspace_id) is None
    assert all(sqlite_session.get(AgentWorkspaceBinding, binding_id) is None for binding_id in binding_ids)


def test_collect_retired_workspace_without_retired_binding_raises(
    monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
    workspace = _workspace(status=AgentWorkingResourceStatus.RETIRED)
    sqlite_session.add(workspace)
    sqlite_session.commit()
    monkeypatch.setattr(
        "services.agent.workspace_service.session_factory.create_session",
        lambda: nullcontext(sqlite_session),
    )

    with pytest.raises(AgentWorkspaceError, match="tenant_id=tenant-1, workspace_id=workspace-1"):
        AgentWorkspaceService.collect_retired_workspace(
            tenant_id="tenant-1",
            workspace_id=workspace.id,
        )


def test_binding_collection_database_failure_propagates(monkeypatch: pytest.MonkeyPatch) -> None:
    context = MagicMock()
    session = context.__enter__.return_value
    error = RuntimeError("database unavailable")
    session.scalar.side_effect = error
    monkeypatch.setattr("services.agent.workspace_service.session_factory.create_session", lambda: context)

    with pytest.raises(RuntimeError) as exc_info:
        AgentWorkspaceService.collect_retired_binding(tenant_id="tenant-1", binding_id="binding-1")

    assert exc_info.value is error


@pytest.mark.parametrize("sqlite_session", [(AgentWorkspace, AgentWorkspaceBinding)], indirect=True)
def test_binding_collection_backend_failure_propagates_and_preserves_retired_binding(
    monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
    workspace = _workspace()
    binding = _binding(status=AgentWorkingResourceStatus.RETIRED)
    sqlite_session.add_all([workspace, binding])
    sqlite_session.commit()
    error = RuntimeError("Agent backend unavailable")
    client = MagicMock()
    client.destroy_execution_binding_sync.side_effect = error
    monkeypatch.setattr(
        "services.agent.workspace_service.session_factory.create_session", lambda: nullcontext(sqlite_session)
    )
    monkeypatch.setattr(AgentWorkspaceService, "_client", lambda: nullcontext(client))

    with pytest.raises(RuntimeError) as exc_info:
        AgentWorkspaceService.collect_retired_binding(tenant_id="tenant-1", binding_id=binding.id)

    assert exc_info.value is error
    stored_binding = sqlite_session.get(AgentWorkspaceBinding, binding.id)
    assert stored_binding is not None
    assert stored_binding.status is AgentWorkingResourceStatus.RETIRED


@pytest.mark.parametrize("sqlite_session", [(AgentWorkspace, AgentWorkspaceBinding)], indirect=True)
def test_workspace_collection_backend_failure_propagates_and_preserves_retired_resources(
    monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
    workspace = _workspace(status=AgentWorkingResourceStatus.RETIRED)
    anchor = _binding(status=AgentWorkingResourceStatus.RETIRED)
    sqlite_session.add_all([workspace, anchor])
    sqlite_session.commit()
    error = RuntimeError("Agent backend unavailable")
    client = MagicMock()
    client.destroy_execution_binding_sync.side_effect = error
    monkeypatch.setattr(
        "services.agent.workspace_service.session_factory.create_session", lambda: nullcontext(sqlite_session)
    )
    monkeypatch.setattr(AgentWorkspaceService, "_client", lambda: nullcontext(client))

    with pytest.raises(RuntimeError) as exc_info:
        AgentWorkspaceService.collect_retired_workspace(tenant_id="tenant-1", workspace_id=workspace.id)

    assert exc_info.value is error
    stored_workspace = sqlite_session.get(AgentWorkspace, workspace.id)
    stored_anchor = sqlite_session.get(AgentWorkspaceBinding, anchor.id)
    assert stored_workspace is not None
    assert stored_workspace.status is AgentWorkingResourceStatus.RETIRED
    assert stored_anchor is not None
    assert stored_anchor.status is AgentWorkingResourceStatus.RETIRED


@pytest.mark.parametrize("sqlite_session", [(AgentWorkspace, AgentWorkspaceBinding)], indirect=True)
def test_workspace_collection_final_delete_failure_propagates(
    monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
    workspace = _workspace(status=AgentWorkingResourceStatus.RETIRED)
    anchor = _binding(status=AgentWorkingResourceStatus.RETIRED)
    sqlite_session.add_all([workspace, anchor])
    sqlite_session.commit()
    error = RuntimeError("database unavailable")
    commit = MagicMock(side_effect=error)
    client = MagicMock()
    monkeypatch.setattr(
        "services.agent.workspace_service.session_factory.create_session", lambda: nullcontext(sqlite_session)
    )
    monkeypatch.setattr(sqlite_session, "commit", commit)
    monkeypatch.setattr(AgentWorkspaceService, "_client", lambda: nullcontext(client))

    with pytest.raises(RuntimeError) as exc_info:
        AgentWorkspaceService.collect_retired_workspace(tenant_id="tenant-1", workspace_id="workspace-1")

    assert exc_info.value is error
    client.destroy_execution_binding_sync.assert_called_once()


def test_binding_creation_ignores_unavailable_metering_configuration(
    monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
    apply_config_overrides(
        monkeypatch,
        AGENT_SANDBOX_METERING_ENABLED=True,
        AGENT_SANDBOX_METERING_PROJECT_ID="",
        AGENT_SANDBOX_METERING_START_AT="invalid",
    )
    client = _backend_client()
    monkeypatch.setattr(AgentWorkspaceService, "_client", lambda: nullcontext(client))
    binding = AgentWorkspaceService.create_binding(
        session=sqlite_session,
        scope=_scope(),
        agent_id="agent-1",
        base_home_snapshot_id=None,
        agent_config_version_id="config-1",
        agent_config_version_kind=AgentConfigVersionKind.SNAPSHOT,
    )
    sqlite_session.commit()
    assert binding.backend_binding_ref == "binding-ref"
    client.create_execution_binding_sync.assert_called_once()


def test_binding_lookups_ignore_bad_metering_configuration_and_remain_tenant_scoped(
    monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
    apply_config_overrides(
        monkeypatch,
        AGENT_SANDBOX_METERING_ENABLED=True,
        AGENT_SANDBOX_METERING_PROJECT_ID="",
        AGENT_SANDBOX_METERING_START_AT="invalid",
    )
    workspace, binding = _workspace(), _binding()
    sqlite_session.add_all([workspace, binding])
    sqlite_session.commit()
    assert (
        AgentWorkspaceService.get_active_binding(
            session=sqlite_session,
            tenant_id=binding.tenant_id,
            binding_id=binding.id,
            expected_owner_scope=_scope(),
        )
        is binding
    )
    assert (
        AgentWorkspaceService.resolve_active_binding_for_scope(
            session=sqlite_session,
            scope=_scope(),
            agent_id=binding.agent_id,
        )
        is binding
    )
    assert (
        AgentWorkspaceService.get_active_binding(
            session=sqlite_session,
            tenant_id="another-tenant",
            binding_id=binding.id,
            expected_owner_scope=_scope(),
        )
        is None
    )