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.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
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
)