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
test: migrate app service sessions to SQLite (#40088)
Asuka Minato7162450e831e
diff --git a/api/tests/unit_tests/services/test_app_service.py b/api/tests/unit_tests/services/test_app_service.pyindex 853838fdd55..beb8d63a040 100644--- a/api/tests/unit_tests/services/test_app_service.py+++ b/api/tests/unit_tests/services/test_app_service.py@@ -3,32 +3,95 @@ from __future__ import annotationsfrom collections.abc import Callablefrom datetime import datetimefrom types import SimpleNamespace-from typing import castfrom unittest.mock import MagicMock, patchfrom uuid import uuid4import pytestfrom sqlalchemy import event-from sqlalchemy.exc import IntegrityErrorfrom sqlalchemy.orm import Sessionfrom graphon.model_runtime.entities.model_entities import ModelTypefrom models import Account, Tenant+from models.account import TenantAccountJoin, TenantAccountRole+from models.agent import Agent, AgentIconType, AgentScope, AgentSource, AgentStatusfrom models.model import App, AppMode, AppModelConfig, IconTypefrom models.workflow import Workflowfrom services.agent.errors import AgentAccessNotReadyError, AgentNameConflictErrorfrom services.app_service import AppListParams, AppService, CreateAppParams+def _persist_account(session: Session) -> Account:+ tenant = Tenant(name="App Service Workspace")+ account = Account(name="Test Account", email=f"app-service-{uuid4()}@example.com")+ membership = TenantAccountJoin(+ tenant_id=tenant.id,+ account_id=account.id,+ current=True,+ role=TenantAccountRole.OWNER,+ )+ account._current_tenant = tenant+ session.add_all([tenant, account, membership])+ session.commit()+ return account+++def _persist_app(session: Session, *, tenant_id: str, name: str = "Visible App") -> App:+ app = App(+ id=str(uuid4()),+ tenant_id=tenant_id,+ name=name,+ mode=AppMode.CHAT,+ icon_type=IconType.EMOJI,+ icon="chat",+ icon_background="#FFFFFF",+ enable_site=False,+ enable_api=False,+ )+ session.add(app)+ session.commit()+ return app+++def _persist_agent_app(session: Session, *, app_name: str = "Old", agent_name: str = "Old") -> tuple[App, Agent]:+ tenant_id = str(uuid4())+ creator_id = str(uuid4())+ app = App(+ id=str(uuid4()),+ tenant_id=tenant_id,+ name=app_name,+ description="old",+ mode=AppMode.AGENT,+ icon_type=IconType.EMOJI,+ icon="robot",+ icon_background="#fff",+ enable_site=False,+ enable_api=False,+ created_by=creator_id,+ )+ agent = Agent(+ tenant_id=tenant_id,+ name=agent_name,+ description="old",+ role="research assistant",+ scope=AgentScope.ROSTER,+ source=AgentSource.AGENT_APP,+ status=AgentStatus.ACTIVE,+ icon_type=AgentIconType.EMOJI,+ icon="robot",+ icon_background="#fff",+ app_id=app.id,+ created_by=creator_id,+ )+ session.add_all([app, agent])+ session.commit()+ return app, agent++class TestCreateAppTransactionBoundary:- def test_commits_database_state_before_external_side_effects(self) -> None:- session = MagicMock()- account = Account(name="Test Account", email="[email protected]")- account.id = "account-1"- account._current_tenant = Tenant(name="Test Tenant")- account._current_tenant.id = "tenant-1"+ def test_commits_database_state_before_external_side_effects(self, sqlite_session: Session) -> None:+ account = _persist_account(sqlite_session)phase_events: list[str] = []- session.commit.side_effect = lambda: phase_events.append("commit")+ event.listen(sqlite_session, "after_commit", lambda _session: phase_events.append("commit"))with (patch(@@ -45,21 +108,18 @@ class TestCreateAppTransactionBoundary:),patch("services.app_service.dify_config.BILLING_ENABLED", False),):- AppService().create_app(- "tenant-1",+ app = AppService().create_app(+ account.current_tenant_id,CreateAppParams(name="Workflow", mode=AppMode.WORKFLOW.value),account,- session=session,+ session=sqlite_session,)assert phase_events == ["commit", "signal", "commit", "external"]+ assert sqlite_session.get(App, app.id) is app- def test_falls_back_when_default_model_schema_is_unavailable(self) -> None:- session = MagicMock()- account = Account(name="Test Account", email="[email protected]")- account.id = "account-1"- account._current_tenant = Tenant(name="Test Tenant")- account._current_tenant.id = "tenant-1"+ def test_falls_back_when_default_model_schema_is_unavailable(self, sqlite_session: Session) -> None:+ account = _persist_account(sqlite_session)model_type_instance = MagicMock()model_type_instance.get_model_schema.side_effect = ValueError("Base model unknown-model not found")model_instance = SimpleNamespace(@@ -71,9 +131,6 @@ class TestCreateAppTransactionBoundary:model_manager = MagicMock()model_manager.get_default_model_instance.return_value = model_instancemodel_manager.get_default_provider_model_name.return_value = ("openai", "gpt-4o")- added_objects: list[object] = []- session.add.side_effect = added_objects.append-with (patch("services.app_service.ModelManager.for_tenant", return_value=model_manager),patch("services.app_service.app_was_created.send"),@@ -85,13 +142,14 @@ class TestCreateAppTransactionBoundary:patch("services.app_service.dify_config.BILLING_ENABLED", False),):app = AppService().create_app(- "tenant-1",+ account.current_tenant_id,CreateAppParams(name="Chat", mode=AppMode.CHAT.value),account,- session=session,+ session=sqlite_session,)- app_model_config = next(obj for obj in added_objects if isinstance(obj, AppModelConfig))+ app_model_config = sqlite_session.get(AppModelConfig, app.app_model_config_id)+ assert app_model_config is not Noneassert app.mode == AppMode.CHATassert app_model_config.model_dict == {"provider": "openai",@@ -100,7 +158,7 @@ class TestCreateAppTransactionBoundary:"completion_params": {},}model_manager.get_default_provider_model_name.assert_called_once_with(- tenant_id="tenant-1", model_type=ModelType.LLM+ tenant_id=account.current_tenant_id, model_type=ModelType.LLM)@@ -108,17 +166,17 @@ class TestCreateAppTransactionBoundary:"update_status",[AppService.update_app_site_status, AppService.update_app_api_status],)-def test_app_status_updates_commit_before_signal(update_status: Callable[..., App]) -> None:- app = cast(App, SimpleNamespace(enable_site=False, enable_api=False, mode=AppMode.CHAT))- session = MagicMock()+def test_app_status_updates_commit_before_signal(update_status: Callable[..., App], sqlite_session: Session) -> None:+ account = _persist_account(sqlite_session)+ app = _persist_app(sqlite_session, tenant_id=account.current_tenant_id or "")phase_events: list[str] = []- session.commit.side_effect = lambda: phase_events.append("commit")+ event.listen(sqlite_session, "after_commit", lambda _session: phase_events.append("commit"))with (- patch("services.app_service.current_user", SimpleNamespace(id="account-1")),+ patch("services.app_service.current_user", account),patch("services.app_service.app_was_updated.send", side_effect=lambda *_args: phase_events.append("signal")),):- update_status(AppService(), app, True, session=session)+ update_status(AppService(), app, True, session=sqlite_session)assert phase_events == ["commit", "signal"]@@ -130,27 +188,20 @@ def test_app_status_updates_commit_before_signal(update_status: Callable[..., ApAppService.update_app_api_status,],)-def test_unpublished_agent_app_access_cannot_be_enabled(update_status: Callable[..., App]) -> None:- app = cast(- App,- SimpleNamespace(- id="app-1",- tenant_id="tenant-1",- mode=AppMode.AGENT,- enable_site=False,- enable_api=False,- ),- )- session = MagicMock()- session.scalar.return_value = SimpleNamespace(id="agent-1")+def test_unpublished_agent_app_access_cannot_be_enabled(+ update_status: Callable[..., App], sqlite_session: Session+) -> None:+ app, _ = _persist_agent_app(sqlite_session)+ commits: list[str] = []+ event.listen(sqlite_session, "after_commit", lambda _session: commits.append("commit"))with patch("services.app_service.agent_has_workflow_callable_active_snapshot", return_value=False):with pytest.raises(AgentAccessNotReadyError):- update_status(AppService(), app, True, session=session)+ update_status(AppService(), app, True, session=sqlite_session)assert app.enable_site is Falseassert app.enable_api is False- session.commit.assert_not_called()+ assert commits == []class TestOpenapiVisibilityHelpers:@@ -160,127 +211,96 @@ class TestOpenapiVisibilityHelpers:gate passes" check so the controller can stay free of SQL."""- def test_get_app_by_id_is_plain_session_get(self):+ def test_get_app_by_id_is_plain_session_get(self, sqlite_session: Session):"""``get_app_by_id`` must NOT apply status / visibility filters— callers (e.g. the openapi auth pipeline) need to differentiate404 (missing) from 403 (``enable_api`` off) and would lose thatsignal if the helper coalesced both into ``None``."""- mock_session = MagicMock()- sentinel_app = App(- status="archived",- ) # explicitly NOT "normal"- mock_session.get.return_value = sentinel_app+ sentinel_app = _persist_app(sqlite_session, tenant_id=str(uuid4()))+ sentinel_app.status = "archived" # type: ignore[assignment]- assert AppService.get_app_by_id("app-uuid", mock_session) is sentinel_app- mock_session.get.assert_called_once_with(App, "app-uuid")+ assert AppService.get_app_by_id(sentinel_app.id, sqlite_session) is sentinel_app- def test_get_app_by_id_returns_none_when_missing(self):- mock_session = MagicMock()- mock_session.get.return_value = None+ def test_get_app_by_id_returns_none_when_missing(self, sqlite_session: Session):+ assert AppService.get_app_by_id(str(uuid4()), sqlite_session) is None- assert AppService.get_app_by_id("missing", mock_session) is None-- def test_get_visible_app_by_id_returns_app_when_visible(self):- mock_session = MagicMock()- app = App(- status="normal",- )- mock_session.get.return_value = app+ def test_get_visible_app_by_id_returns_app_when_visible(self, sqlite_session: Session):+ app = _persist_app(sqlite_session, tenant_id=str(uuid4()))with patch("services.app_service.is_openapi_visible", return_value=True):- assert AppService.get_visible_app_by_id("app-uuid", mock_session) is app-- mock_session.get.assert_called_once_with(App, "app-uuid")+ assert AppService.get_visible_app_by_id(app.id, sqlite_session) is app- def test_get_visible_app_by_id_returns_none_when_row_missing(self):- mock_session = MagicMock()- mock_session.get.return_value = None+ def test_get_visible_app_by_id_returns_none_when_row_missing(self, sqlite_session: Session):+ assert AppService.get_visible_app_by_id(str(uuid4()), sqlite_session) is None- assert AppService.get_visible_app_by_id("missing", mock_session) is None-- def test_get_visible_app_by_id_returns_none_when_status_not_normal(self):+ def test_get_visible_app_by_id_returns_none_when_status_not_normal(self, sqlite_session: Session):"""Soft-deleted/archived rows must not surface on the openapisurface — the helper hides them by returning ``None``."""- mock_session = MagicMock()- app = App(- status="archived",- )- mock_session.get.return_value = app+ app = _persist_app(sqlite_session, tenant_id=str(uuid4()))+ app.status = "archived" # type: ignore[assignment]with patch("services.app_service.is_openapi_visible", return_value=True):- assert AppService.get_visible_app_by_id("app-uuid", mock_session) is None+ assert AppService.get_visible_app_by_id(app.id, sqlite_session) is None- def test_get_visible_app_by_id_returns_none_when_visibility_gate_rejects(self):+ def test_get_visible_app_by_id_returns_none_when_visibility_gate_rejects(self, sqlite_session: Session):"""``is_openapi_visible`` is the per-row counterpart to``apply_openapi_gate`` — when it returns False the helper musttreat the row as invisible (not "found but unauthorized")."""- mock_session = MagicMock()- app = App(- status="normal",- )- mock_session.get.return_value = app+ app = _persist_app(sqlite_session, tenant_id=str(uuid4()))with patch("services.app_service.is_openapi_visible", return_value=False):- assert AppService.get_visible_app_by_id("app-uuid", mock_session) is None+ assert AppService.get_visible_app_by_id(app.id, sqlite_session) is None- def test_find_visible_apps_by_name_returns_scalars_through_visibility_gate(self):+ def test_find_visible_apps_by_name_returns_scalars_through_visibility_gate(self, sqlite_session: Session):"""Tenant-scoped name lookup. The helper passes the SELECT through``apply_openapi_gate`` and materialises ``.scalars()`` into a listso the controller can branch on length (404 / single / 409)."""- mock_session = MagicMock()- rows = [App(), App()]- mock_session.execute.return_value.scalars.return_value = iter(rows)+ tenant_id = str(uuid4())+ rows = [+ _persist_app(sqlite_session, tenant_id=tenant_id, name="my-app"),+ _persist_app(sqlite_session, tenant_id=tenant_id, name="my-app"),+ ]+ _persist_app(sqlite_session, tenant_id=str(uuid4()), name="my-app")with patch("services.app_service.apply_openapi_gate", side_effect=lambda q: q) as gate:- out = AppService.find_visible_apps_by_name(name="my-app", tenant_id="tenant-1", session=mock_session)+ out = AppService.find_visible_apps_by_name(name="my-app", tenant_id=tenant_id, session=sqlite_session)- assert out == rows+ assert {app.id for app in out} == {app.id for app in rows}# Visibility gate must wrap the SELECT exactly once.gate.assert_called_once()- mock_session.execute.assert_called_once()-- def test_find_visible_apps_by_name_returns_empty_list_on_no_match(self):- mock_session = MagicMock()- mock_session.execute.return_value.scalars.return_value = iter([])+ def test_find_visible_apps_by_name_returns_empty_list_on_no_match(self, sqlite_session: Session):with patch("services.app_service.apply_openapi_gate", side_effect=lambda q: q):- out = AppService.find_visible_apps_by_name(name="nope", tenant_id="tenant-1", session=mock_session)+ out = AppService.find_visible_apps_by_name(name="nope", tenant_id=str(uuid4()), session=sqlite_session)assert out == []- def test_find_visible_apps_by_ids_short_circuits_on_empty_input(self):+ def test_find_visible_apps_by_ids_short_circuits_on_empty_input(self, unbound_session: Session):"""Empty id list must not emit ``WHERE id IN ()`` — Postgresrejects empty IN lists and the call is a guaranteed no-opanyway. The helper returns ``[]`` without touching the session."""- mock_session = MagicMock()-- assert AppService.find_visible_apps_by_ids([], mock_session) == []- mock_session.execute.assert_not_called()+ assert AppService.find_visible_apps_by_ids([], unbound_session) == []- def test_find_visible_apps_by_ids_passes_through_visibility_gate(self):+ def test_find_visible_apps_by_ids_passes_through_visibility_gate(self, sqlite_session: Session):"""Bulk fetch routes through ``apply_openapi_gate`` exactly onceand materialises the scalar rows. **No** status filter isapplied here — the EE permitted-external pipeline filtersnon-normal hits in Python so its page count stays anchored."""- mock_session = MagicMock()- rows = [App(), App()]- mock_session.execute.return_value.scalars.return_value.all.return_value = rows+ rows = [_persist_app(sqlite_session, tenant_id=str(uuid4())) for _ in range(2)]with patch("services.app_service.apply_openapi_gate", side_effect=lambda q: q) as gate:- out = AppService.find_visible_apps_by_ids(["a", "b"], mock_session)+ out = AppService.find_visible_apps_by_ids([app.id for app in rows], sqlite_session)- assert out == rows+ assert {app.id for app in out} == {app.id for app in rows}gate.assert_called_once()- mock_session.execute.assert_called_once()[email protected]("sqlite_session", [(Account, App, AppModelConfig)], indirect=True)def test_get_recent_apps_uses_one_tenant_scoped_projection_query(sqlite_session: Session) -> None:tenant_id = str(uuid4())other_tenant_id = str(uuid4())@@ -370,28 +390,39 @@ def test_get_recent_apps_uses_one_tenant_scoped_projection_query(sqlite_session:class TestAppMeta:- def test_loads_workflow_with_caller_session(self):- session = MagicMock()- session.get.return_value = SimpleNamespace(graph_dict={"nodes": []})- app = cast(App, SimpleNamespace(mode=AppMode.WORKFLOW, workflow_id="workflow-1"))-- assert AppService().get_app_meta(app, session=session) == {"tool_icons": {}}-- session.get.assert_called_once_with(Workflow, "workflow-1")+ def test_loads_workflow_with_caller_session(self, sqlite_session: Session):+ tenant_id = str(uuid4())+ app = _persist_app(sqlite_session, tenant_id=tenant_id)+ app.mode = AppMode.WORKFLOW+ workflow = Workflow(+ id=str(uuid4()),+ tenant_id=tenant_id,+ app_id=app.id,+ type="workflow",+ version="draft",+ graph='{"nodes": []}',+ features="{}",+ created_by=str(uuid4()),+ )+ app.workflow_id = workflow.id+ sqlite_session.add(workflow)+ sqlite_session.commit()- def test_loads_app_model_config_with_caller_session(self):- session = MagicMock()- session.get.return_value = SimpleNamespace(agent_mode_dict={"tools": []})- app = cast(App, SimpleNamespace(mode=AppMode.CHAT, app_model_config_id="config-1"))+ assert AppService().get_app_meta(app, session=sqlite_session) == {"tool_icons": {}}- assert AppService().get_app_meta(app, session=session) == {"tool_icons": {}}+ def test_loads_app_model_config_with_caller_session(self, sqlite_session: Session):+ app = _persist_app(sqlite_session, tenant_id=str(uuid4()))+ config = AppModelConfig(app_id=app.id, agent_mode='{"tools": []}')+ sqlite_session.add(config)+ sqlite_session.flush()+ app.app_model_config_id = config.id+ sqlite_session.commit()- session.get.assert_called_once_with(AppModelConfig, "config-1")+ assert AppService().get_app_meta(app, session=sqlite_session) == {"tool_icons": {}}class TestGetApp:- def test_legacy_agent_detection_uses_caller_session(self):- session = MagicMock()+ def test_legacy_agent_detection_uses_caller_session(self, unbound_session: Session):app = App(mode=AppMode.CHAT,)@@ -404,13 +435,12 @@ class TestGetApp:patch.object(App, "app_model_config_with_session") as get_model_config,patch("services.app_service.current_user", account),):- assert AppService().get_app(app, session=session) is app+ assert AppService().get_app(app, session=unbound_session) is app- is_agent.assert_called_once_with(session=session)+ is_agent.assert_called_once_with(session=unbound_session)get_model_config.assert_not_called()- def test_agent_model_config_uses_caller_session(self):- session = MagicMock()+ def test_agent_model_config_uses_caller_session(self, unbound_session: Session):app = App(mode=AppMode.AGENT_CHAT,)@@ -423,10 +453,10 @@ class TestGetApp:patch.object(App, "app_model_config_with_session", return_value=None) as get_model_config,patch("services.app_service.current_user", account),):- assert AppService().get_app(app, session=session) is app+ assert AppService().get_app(app, session=unbound_session) is appis_agent.assert_not_called()- get_model_config.assert_called_once_with(session=session)+ get_model_config.assert_called_once_with(session=unbound_session)class TestAgentAppType:@@ -459,43 +489,16 @@ class TestAgentAppType:)assert app.bound_agent_id is None- def test_update_agent_app_syncs_backing_agent_identity(self):- from models.agent import AgentIconType- from models.model import AppMode, IconType- from services.app_service import AppService-- app = SimpleNamespace(- id="app-1",- tenant_id="tenant-1",- mode=AppMode.AGENT,- name="Old",- description="old",- role="draft",- icon_type=IconType.EMOJI,- icon="robot",- icon_background="#fff",- use_icon_as_answer_icon=False,- max_active_requests=None,- created_by="account-1",- )- backing_agent = SimpleNamespace(- name="Old",- description="old",- role="draft",- icon_type=AgentIconType.EMOJI,- icon="robot",- icon_background="#fff",- updated_by=None,- updated_at=None,- )+ def test_update_agent_app_syncs_backing_agent_identity(self, sqlite_session: Session):+ app, backing_agent = _persist_agent_app(sqlite_session)+ account_id = str(uuid4())with (- patch("services.app_service.db") as mock_db,- patch("services.app_service.current_user", SimpleNamespace(id="account-2")),+ patch("services.app_service.current_user", SimpleNamespace(id=account_id)),+ patch("services.app_service.app_was_updated.send"),):- mock_db.session.scalar.return_value = backing_agentupdated_app = AppService().update_app(- app, # type: ignore[arg-type]+ app,{"name": "Iris","description": "agent app",@@ -506,7 +509,7 @@ class TestAgentAppType:"use_icon_as_answer_icon": False,"max_active_requests": 0,},- session=mock_db.session,+ session=sqlite_session,)assert updated_app.name == "Iris"@@ -516,46 +519,18 @@ class TestAgentAppType:assert backing_agent.icon_type == AgentIconType.IMAGEassert backing_agent.icon == "file-id"assert backing_agent.icon_background == "#123456"- assert backing_agent.updated_by == "account-2"+ assert backing_agent.updated_by == account_idassert backing_agent.updated_at == updated_app.updated_at- def test_update_agent_app_preserves_role_when_args_omit_it(self):- from models.agent import AgentIconType- from models.model import AppMode, IconType- from services.app_service import AppService-- app = SimpleNamespace(- id="app-1",- tenant_id="tenant-1",- mode=AppMode.AGENT,- name="Old",- description="old",- role="draft",- icon_type=IconType.EMOJI,- icon="robot",- icon_background="#fff",- use_icon_as_answer_icon=False,- max_active_requests=None,- created_by="account-1",- )- backing_agent = SimpleNamespace(- name="Old",- description="old",- role="research assistant",- icon_type=AgentIconType.EMOJI,- icon="robot",- icon_background="#fff",- updated_by=None,- updated_at=None,- )+ def test_update_agent_app_preserves_role_when_args_omit_it(self, sqlite_session: Session):+ app, backing_agent = _persist_agent_app(sqlite_session)with (- patch("services.app_service.db") as mock_db,- patch("services.app_service.current_user", SimpleNamespace(id="account-2")),+ patch("services.app_service.current_user", SimpleNamespace(id=str(uuid4()))),+ patch("services.app_service.app_was_updated.send"),):- mock_db.session.scalar.return_value = backing_agentAppService().update_app(- app, # type: ignore[arg-type]+ app,{"name": "Iris","description": "agent app",@@ -565,48 +540,20 @@ class TestAgentAppType:"use_icon_as_answer_icon": False,"max_active_requests": 0,},- session=mock_db.session,+ session=sqlite_session,)assert backing_agent.role == "research assistant"- def test_update_agent_app_clears_role_when_args_set_empty_string(self):- from models.agent import AgentIconType- from models.model import AppMode, IconType- from services.app_service import AppService-- app = SimpleNamespace(- id="app-1",- tenant_id="tenant-1",- mode=AppMode.AGENT,- name="Old",- description="old",- role="draft",- icon_type=IconType.EMOJI,- icon="robot",- icon_background="#fff",- use_icon_as_answer_icon=False,- max_active_requests=None,- created_by="account-1",- )- backing_agent = SimpleNamespace(- name="Old",- description="old",- role="research assistant",- icon_type=AgentIconType.EMOJI,- icon="robot",- icon_background="#fff",- updated_by=None,- updated_at=None,- )+ def test_update_agent_app_clears_role_when_args_set_empty_string(self, sqlite_session: Session):+ app, backing_agent = _persist_agent_app(sqlite_session)with (- patch("services.app_service.db") as mock_db,- patch("services.app_service.current_user", SimpleNamespace(id="account-2")),+ patch("services.app_service.current_user", SimpleNamespace(id=str(uuid4()))),+ patch("services.app_service.app_was_updated.send"),):- mock_db.session.scalar.return_value = backing_agentAppService().update_app(- app, # type: ignore[arg-type]+ app,{"name": "Iris","description": "agent app",@@ -617,50 +564,34 @@ class TestAgentAppType:"use_icon_as_answer_icon": False,"max_active_requests": 0,},- session=mock_db.session,+ session=sqlite_session,)assert backing_agent.role == ""- def test_update_agent_app_duplicate_name_rolls_back_and_raises_conflict(self):- from models.agent import AgentIconType- from models.model import AppMode, IconType- from services.app_service import AppService-- app = SimpleNamespace(- id="app-1",- tenant_id="tenant-1",- mode=AppMode.AGENT,- name="Old",- description="old",- role="draft",- icon_type=IconType.EMOJI,- icon="robot",- icon_background="#fff",- use_icon_as_answer_icon=False,- max_active_requests=None,- created_by="account-1",- )- backing_agent = SimpleNamespace(- name="Old",- description="old",- role="research assistant",- icon_type=AgentIconType.EMOJI,- icon="robot",- icon_background="#fff",- updated_by=None,- updated_at=None,+ def test_update_agent_app_duplicate_name_rolls_back_and_raises_conflict(self, sqlite_session: Session):+ app, backing_agent = _persist_agent_app(sqlite_session)+ existing = Agent(+ tenant_id=app.tenant_id,+ name="Existing Agent",+ description="existing",+ role="",+ scope=AgentScope.ROSTER,+ source=AgentSource.ROSTER,+ status=AgentStatus.ACTIVE,)+ sqlite_session.add(existing)+ sqlite_session.commit()+ rollback_events: list[str] = []+ event.listen(sqlite_session, "after_rollback", lambda _session: rollback_events.append("rollback"))with (- patch("services.app_service.db") as mock_db,- patch("services.app_service.current_user", SimpleNamespace(id="account-2")),+ patch("services.app_service.current_user", SimpleNamespace(id=str(uuid4()))),+ patch("services.app_service.app_was_updated.send"),):- mock_db.session.scalar.return_value = backing_agent- mock_db.session.commit.side_effect = IntegrityError("duplicate", None, None)with pytest.raises(AgentNameConflictError):AppService().update_app(- app, # type: ignore[arg-type]+ app,{"name": "Existing Agent","description": "agent app",@@ -671,23 +602,39 @@ class TestAgentAppType:"use_icon_as_answer_icon": False,"max_active_requests": 0,},- session=mock_db.session,+ session=sqlite_session,)- mock_db.session.rollback.assert_called_once()-- def test_delete_agent_app_archives_backing_agent(self):- from models.agent import AgentStatus- from models.model import AppMode- from services.app_service import AppService-- app = SimpleNamespace(id="app-1", tenant_id="tenant-1", mode=AppMode.AGENT)- backing_agent = SimpleNamespace(id="agent-1", status=AgentStatus.ACTIVE, archived_by=None, archived_at=None)+ assert rollback_events == ["rollback"]+ sqlite_session.expire_all()+ assert sqlite_session.get(Agent, backing_agent.id).name == "Old" # type: ignore[union-attr]++ def test_delete_agent_app_archives_backing_agent(self, sqlite_session: Session):+ app, backing_agent = _persist_agent_app(sqlite_session)+ workflow_agents = [+ Agent(+ tenant_id=app.tenant_id,+ name=f"Workflow Agent {index}",+ description="",+ role="",+ scope=AgentScope.WORKFLOW_ONLY,+ source=AgentSource.WORKFLOW,+ status=AgentStatus.ACTIVE,+ app_id=app.id,+ workflow_id=str(uuid4()),+ workflow_node_id=f"node-{index}",+ )+ for index in range(2)+ ]+ sqlite_session.add_all(workflow_agents)+ sqlite_session.commit()+ account_id = str(uuid4())events: list[str] = []+ event.listen(sqlite_session, "after_commit", lambda _session: events.append("commit"))with (- patch("services.app_service.db") as mock_db,- patch("services.app_service.current_user", SimpleNamespace(id="account-2")),+ patch("services.app_service.current_user", SimpleNamespace(id=account_id)),+ patch("services.app_service.app_was_deleted.send"),patch("services.app_service.BillingService"),patch("services.app_service.EnterpriseService"),patch("services.app_service.FeatureService"),@@ -712,62 +659,67 @@ class TestAgentAppType:side_effect=lambda **_kwargs: events.append("enqueue"),) as mock_enqueue_collection,):- mock_db.session.scalar.return_value = backing_agent- mock_db.session.commit.side_effect = lambda: events.append("commit")- workflow_agents = MagicMock()- workflow_agents.all.return_value = ["workflow-agent-1", "workflow-agent-2"]- bindings = MagicMock()- bindings.all.return_value = []- mock_db.session.scalars.side_effect = [workflow_agents, bindings]- AppService().delete_app(app, session=mock_db.session) # type: ignore[arg-type]+ AppService().delete_app(app, session=sqlite_session)assert events == ["retire-app-workspaces", "commit", "retire-workflow-agents", "enqueue"]- assert backing_agent.status == AgentStatus.ARCHIVED- assert backing_agent.archived_by == "account-2"- assert backing_agent.archived_at is not None- mock_db.session.delete.assert_called_once_with(app)+ sqlite_session.expire_all()+ persisted_agent = sqlite_session.get(Agent, backing_agent.id)+ assert persisted_agent is not None+ assert sqlite_session.get(App, app.id) is None+ assert persisted_agent.status == AgentStatus.ARCHIVED+ assert persisted_agent.archived_by == account_id+ assert persisted_agent.archived_at is not Nonemock_workflow_retirement.assert_called_once_with(- tenant_id="tenant-1",- agent_ids=["workflow-agent-1", "workflow-agent-2"],- account_id="account-2",+ tenant_id=app.tenant_id,+ agent_ids=[agent.id for agent in workflow_agents],+ account_id=account_id,)mock_retire_workspaces.assert_called_once_with(- session=mock_db.session,- tenant_id="tenant-1",- app_id="app-1",+ session=sqlite_session,+ tenant_id=app.tenant_id,+ app_id=app.id,)mock_retire_homes.assert_called_once_with(- session=mock_db.session,- tenant_id="tenant-1",- agent_id="agent-1",+ session=sqlite_session,+ tenant_id=app.tenant_id,+ agent_id=backing_agent.id,)mock_enqueue_collection.assert_called_once_with(- tenant_id="tenant-1",+ tenant_id=app.tenant_id,workspace_ids=["workspace-1"],binding_ids=["workflow-binding-1"],home_snapshot_ids=["home-1", "workflow-home-1"],)- def test_delete_app_commit_failure_does_not_retire_workflow_agents_or_enqueue(self):- from models.model import AppMode- from services.app_service import AppService-- app = SimpleNamespace(id="app-1", tenant_id="tenant-1", mode=AppMode.WORKFLOW)+ def test_delete_app_commit_failure_does_not_retire_workflow_agents_or_enqueue(+ self, sqlite_session: Session, monkeypatch: pytest.MonkeyPatch+ ):+ app = _persist_app(sqlite_session, tenant_id=str(uuid4()))+ app.mode = AppMode.WORKFLOW+ workflow_agent = Agent(+ tenant_id=app.tenant_id,+ name="Workflow Agent",+ description="",+ role="",+ scope=AgentScope.WORKFLOW_ONLY,+ source=AgentSource.WORKFLOW,+ status=AgentStatus.ACTIVE,+ app_id=app.id,+ workflow_id=str(uuid4()),+ workflow_node_id="node-1",+ )+ sqlite_session.add(workflow_agent)+ sqlite_session.commit()+ monkeypatch.setattr(sqlite_session, "commit", MagicMock(side_effect=RuntimeError("commit failed")))with (- patch("services.app_service.db") as mock_db,- patch("services.app_service.current_user", SimpleNamespace(id="account-2")),+ patch("services.app_service.current_user", SimpleNamespace(id=str(uuid4()))),+ patch("services.app_service.app_was_deleted.send"),patch("services.app_service.AgentWorkspaceService.retire_all_for_app", return_value=["workspace-1"]),patch("services.app_service.WorkflowAgentRetirementService.retire_unowned") as retire_unowned,patch("services.app_service.enqueue_agent_resource_collection") as enqueue_collection,):- mock_db.session.scalar.return_value = None- workflow_agents = MagicMock()- workflow_agents.all.return_value = ["workflow-agent-1"]- mock_db.session.scalars.return_value = workflow_agents- mock_db.session.commit.side_effect = RuntimeError("commit failed")-with pytest.raises(RuntimeError, match="commit failed"):- AppService().delete_app(app, session=mock_db.session) # type: ignore[arg-type]+ AppService().delete_app(app, session=sqlite_session)retire_unowned.assert_not_called()enqueue_collection.assert_not_called()diff --git a/api/tests/unit_tests/services/test_audio_service.py b/api/tests/unit_tests/services/test_audio_service.pyindex 0722faad651..1dd1277c2fb 100644--- a/api/tests/unit_tests/services/test_audio_service.py+++ b/api/tests/unit_tests/services/test_audio_service.py@@ -224,6 +224,10 @@ def factory():class TestAudioServiceASR:"""Test speech-to-text (ASR) operations."""+ @pytest.fixture(autouse=True)+ def _bind_sqlite_session(self, sqlite_session: Session) -> None:+ self.session = sqlite_session+@patch("services.audio_service.ModelManager.for_tenant", autospec=True)def test_transcript_asr_success_chat_mode(self, mock_model_manager_class, factory: AudioServiceTestDataFactory):"""Test successful ASR transcription in CHAT mode."""@@ -242,7 +246,7 @@ class TestAudioServiceASR:mock_model_manager.get_default_model_instance.return_value = mock_model_instance# Act- result = AudioService.transcript_asr(app_model=app, file=file, session=MagicMock(), end_user="user-123")+ result = AudioService.transcript_asr(app_model=app, file=file, session=self.session, end_user="user-123")# Assertassert result == {"text": "Transcribed text"}@@ -269,7 +273,7 @@ class TestAudioServiceASR:mock_model_manager.get_default_model_instance.return_value = mock_model_instance# Act- result = AudioService.transcript_asr(app_model=app, file=file, session=MagicMock())+ result = AudioService.transcript_asr(app_model=app, file=file, session=self.session)# Assertassert result == {"text": "Workflow transcribed text"}@@ -290,7 +294,7 @@ class TestAudioServiceASR:mock_model_instance.invoke_speech2text.return_value = "Published Agent transcript"mock_model_manager_class.return_value.get_default_model_instance.return_value = mock_model_instance- result = AudioService.transcript_asr(app_model=app, file=file, session=MagicMock(), end_user="end-user-1")+ result = AudioService.transcript_asr(app_model=app, file=file, session=self.session, end_user="end-user-1")assert result == {"text": "Published Agent transcript"}mock_roster_service_class.return_value.get_published_agent_soul_for_app.assert_called_once_with(@@ -314,7 +318,7 @@ class TestAudioServiceASR:mock_model_instance.invoke_speech2text.return_value = "Legacy Agent transcript"mock_model_manager_class.return_value.get_default_model_instance.return_value = mock_model_instance- result = AudioService.transcript_asr(app_model=app, file=file, session=MagicMock())+ result = AudioService.transcript_asr(app_model=app, file=file, session=self.session)assert result == {"text": "Legacy Agent transcript"}@@ -333,7 +337,7 @@ class TestAudioServiceASR:app_model=app,agent_soul=agent_soul,file=file,- session=MagicMock(),+ session=self.session,end_user="account-1",)@@ -354,7 +358,7 @@ class TestAudioServiceASR:file = factory.create_file_storage_mock()with pytest.raises(SpeechToTextDisabledServiceError):- AudioService.transcript_agent_asr(app_model=app, agent_soul=agent_soul, file=file, session=MagicMock())+ AudioService.transcript_agent_asr(app_model=app, agent_soul=agent_soul, file=file, session=self.session)@patch("services.audio_service.ModelManager.for_tenant", autospec=True)def test_transcript_agent_asr_preserves_legacy_feature_fallback(@@ -372,7 +376,7 @@ class TestAudioServiceASR:app_model=app,agent_soul=AgentSoulConfig(),file=file,- session=MagicMock(),+ session=self.session,)assert result == {"text": "Legacy feature transcript"}@@ -385,7 +389,7 @@ class TestAudioServiceASR:agent_soul = AgentSoulConfig.model_validate({"app_features": {"speech_to_text": {"enabled": False}}})with pytest.raises(SpeechToTextDisabledServiceError):- AudioService.transcript_agent_asr(app_model=app, agent_soul=agent_soul, file=file, session=MagicMock())+ AudioService.transcript_agent_asr(app_model=app, agent_soul=agent_soul, file=file, session=self.session)def test_transcript_asr_raises_error_when_feature_disabled_chat_mode(self, factory: AudioServiceTestDataFactory):"""Test that ASR raises error when speech-to-text is disabled in CHAT mode."""@@ -399,7 +403,7 @@ class TestAudioServiceASR:# Act & Assertwith pytest.raises(SpeechToTextDisabledServiceError):- AudioService.transcript_asr(app_model=app, file=file, session=MagicMock())+ AudioService.transcript_asr(app_model=app, file=file, session=self.session)def test_transcript_asr_raises_error_when_feature_disabled_workflow_mode(self, factory: AudioServiceTestDataFactory@@ -415,7 +419,7 @@ class TestAudioServiceASR:# Act & Assertwith pytest.raises(SpeechToTextDisabledServiceError):- AudioService.transcript_asr(app_model=app, file=file, session=MagicMock())+ AudioService.transcript_asr(app_model=app, file=file, session=self.session)def test_transcript_asr_raises_error_when_workflow_missing(self, factory: AudioServiceTestDataFactory):"""Test that ASR raises error when workflow is missing in WORKFLOW mode."""@@ -428,7 +432,7 @@ class TestAudioServiceASR:# Act & Assertwith pytest.raises(SpeechToTextDisabledServiceError):- AudioService.transcript_asr(app_model=app, file=file, session=MagicMock())+ AudioService.transcript_asr(app_model=app, file=file, session=self.session)def test_transcript_asr_raises_error_when_no_file_uploaded(self, factory: AudioServiceTestDataFactory):"""Test that ASR raises error when no file is uploaded."""@@ -441,7 +445,7 @@ class TestAudioServiceASR:# Act & Assertwith pytest.raises(NoAudioUploadedServiceError):- AudioService.transcript_asr(app_model=app, file=None, session=MagicMock())+ AudioService.transcript_asr(app_model=app, file=None, session=self.session)def test_transcript_asr_raises_error_for_unsupported_audio_type(self, factory: AudioServiceTestDataFactory):"""Test that ASR raises error for unsupported audio file types."""@@ -455,7 +459,7 @@ class TestAudioServiceASR:# Act & Assertwith pytest.raises(UnsupportedAudioTypeServiceError):- AudioService.transcript_asr(app_model=app, file=file, session=MagicMock())+ AudioService.transcript_asr(app_model=app, file=file, session=self.session)def test_transcript_asr_raises_error_for_large_file(self, factory: AudioServiceTestDataFactory):"""Test that ASR raises error when file exceeds size limit (30MB)."""@@ -471,7 +475,7 @@ class TestAudioServiceASR:# Act & Assertwith pytest.raises(AudioTooLargeServiceError, match="Audio size larger than 30 mb"):- AudioService.transcript_asr(app_model=app, file=file, session=MagicMock())+ AudioService.transcript_asr(app_model=app, file=file, session=self.session)@patch("services.audio_service.ModelManager.for_tenant", autospec=True)def test_transcript_asr_raises_error_when_no_model_instance(@@ -492,10 +496,9 @@ class TestAudioServiceASR:# Act & Assertwith pytest.raises(ProviderNotSupportSpeechToTextServiceError):- AudioService.transcript_asr(app_model=app, file=file, session=MagicMock())+ AudioService.transcript_asr(app_model=app, file=file, session=self.session)[email protected]("sqlite_session", [(Message,)], indirect=True)class TestAudioServiceTTS:"""Test text-to-speech (TTS) operations."""diff --git a/api/tests/unit_tests/services/test_conversation_service.py b/api/tests/unit_tests/services/test_conversation_service.pyindex 79c138ed265..641731c4384 100644--- a/api/tests/unit_tests/services/test_conversation_service.py+++ b/api/tests/unit_tests/services/test_conversation_service.py@@ -11,7 +11,7 @@ import jsonfrom unittest.mock import MagicMock, Mock, patchimport pytest-from sqlalchemy import asc, desc+from sqlalchemy import asc, desc, eventfrom sqlalchemy.orm import Sessionfrom core.app.entities.app_invoke_entities import InvokeFrom@@ -150,18 +150,19 @@ class ConversationServiceTestDataFactory:return conversation-def test_delete_retires_then_commits_before_enqueue(monkeypatch: pytest.MonkeyPatch) -> None:+def test_delete_retires_then_commits_before_enqueue(monkeypatch: pytest.MonkeyPatch, sqlite_session: Session) -> None:app = ConversationServiceTestDataFactory.create_app()conversation = ConversationServiceTestDataFactory.create_conversation()conversation.agent_workspace_binding_id = "conversation-binding-1"- session = MagicMock()+ sqlite_session.add(conversation)+ sqlite_session.flush()events: list[str] = []get_binding = MagicMock(return_value=Mock(id="conversation-binding-1"))retire_binding = MagicMock(side_effect=lambda **_kwargs: events.append("retire") or "conversation-binding-1")monkeypatch.setattr(ConversationService, "get_conversation", MagicMock(return_value=conversation))monkeypatch.setattr(AgentWorkspaceService, "get_active_binding", get_binding)monkeypatch.setattr(AgentWorkspaceService, "retire_binding", retire_binding)- session.commit.side_effect = lambda: events.append("commit")+ event.listen(sqlite_session, "after_commit", lambda _session: events.append("commit"))monkeypatch.setattr(conversation_service,"enqueue_agent_resource_collection",@@ -169,19 +170,22 @@ def test_delete_retires_then_commits_before_enqueue(monkeypatch: pytest.MonkeyPa)monkeypatch.setattr(conversation_service.delete_conversation_related_data, "delay", MagicMock())- ConversationService.delete(app, conversation.id, None, session=session)+ ConversationService.delete(app, conversation.id, None, session=sqlite_session)assert events == ["retire", "commit", "enqueue"]assert get_binding.call_args.kwargs["binding_id"] == "conversation-binding-1"assert retire_binding.call_args.kwargs["binding_id"] == "conversation-binding-1"-def test_delete_commit_failure_does_not_enqueue(monkeypatch: pytest.MonkeyPatch) -> None:+def test_delete_commit_failure_does_not_enqueue(monkeypatch: pytest.MonkeyPatch, sqlite_session: Session) -> None:app = ConversationServiceTestDataFactory.create_app()conversation = ConversationServiceTestDataFactory.create_conversation()conversation.agent_workspace_binding_id = "binding-1"- session = MagicMock()- session.commit.side_effect = RuntimeError("commit failed")+ sqlite_session.add(conversation)+ sqlite_session.flush()+ rollback_events: list[str] = []+ event.listen(sqlite_session, "after_rollback", lambda _session: rollback_events.append("rollback"))+ monkeypatch.setattr(sqlite_session, "commit", MagicMock(side_effect=RuntimeError("commit failed")))monkeypatch.setattr(ConversationService, "get_conversation", MagicMock(return_value=conversation))monkeypatch.setattr(AgentWorkspaceService,@@ -195,14 +199,13 @@ def test_delete_commit_failure_does_not_enqueue(monkeypatch: pytest.MonkeyPatch)monkeypatch.setattr(conversation_service.delete_conversation_related_data, "delay", delete_related)with pytest.raises(RuntimeError, match="commit failed"):- ConversationService.delete(app, conversation.id, None, session=session)+ ConversationService.delete(app, conversation.id, None, session=sqlite_session)- session.rollback.assert_called_once_with()+ assert rollback_events == ["rollback"]enqueue_collection.assert_not_called()delete_related.assert_not_called()[email protected]("sqlite_session", [(Conversation,)], indirect=True)class TestConversationServicePagination:"""Test conversation pagination operations."""diff --git a/api/tests/unit_tests/services/test_metadata_service_session_boundary.py b/api/tests/unit_tests/services/test_metadata_service_session_boundary.pyindex 7832cdf435b..9a23aa48b0b 100644--- a/api/tests/unit_tests/services/test_metadata_service_session_boundary.py+++ b/api/tests/unit_tests/services/test_metadata_service_session_boundary.py@@ -1,8 +1,13 @@from datetime import datetime-from unittest.mock import MagicMock, patch+from unittest.mock import patch++from sqlalchemy import event, select+from sqlalchemy.orm import Sessionfrom core.rag.index_processor.constant.built_in_field import BuiltInFieldfrom models import Account+from models.dataset import Dataset, DatasetMetadata, DatasetMetadataBinding, Document+from models.enums import DataSourceType, DocumentCreatedFromfrom services.dataset_service import DocumentServicefrom services.entities.knowledge_entities.knowledge_entities import (DocumentMetadataOperation,@@ -18,57 +23,74 @@ def _account() -> Account:return account-def test_create_metadata_flushes_without_committing_caller_session() -> None:- session = MagicMock()- session.scalar.return_value = None+def test_create_metadata_flushes_without_committing_caller_session(sqlite_session: Session) -> None:+ transaction_events: list[str] = []+ event.listen(sqlite_session, "after_commit", lambda _session: transaction_events.append("commit"))+ event.listen(sqlite_session, "after_rollback", lambda _session: transaction_events.append("rollback"))metadata = MetadataService.create_metadata("dataset-1",MetadataArgs(type="string", name="author"),_account(),"tenant-1",- session=session,+ session=sqlite_session,)assert metadata.name == "author"- session.flush.assert_called_once_with()- session.commit.assert_not_called()- session.rollback.assert_not_called()---def _document() -> MagicMock:- document = MagicMock()- document.id = "document-1"- document.name = "Document"- document.doc_metadata = {}- document.data_source_type = "upload_file"- document.upload_date = datetime(2026, 1, 1)- document.last_update_date = datetime(2026, 1, 2)- document.uploader = "global-session uploader"- document.get_uploader.return_value = "caller-session uploader"- return document---def test_enable_built_in_field_uses_caller_session_for_uploader() -> None:- session = MagicMock()- dataset = MagicMock(id="dataset-1", built_in_field_enabled=False)+ assert sqlite_session.get(DatasetMetadata, metadata.id) is metadata+ assert transaction_events == []+++def _dataset(*, built_in_field_enabled: bool) -> Dataset:+ return Dataset(+ id="dataset-1",+ tenant_id="tenant-1",+ name="Dataset",+ description="",+ provider="vendor",+ created_by="account-1",+ built_in_field_enabled=built_in_field_enabled,+ )+++def _document() -> Document:+ return Document(+ id="document-1",+ tenant_id="tenant-1",+ dataset_id="dataset-1",+ position=1,+ data_source_type=DataSourceType.UPLOAD_FILE,+ batch="batch-1",+ name="Document",+ created_from=DocumentCreatedFrom.API,+ created_by="account-1",+ created_at=datetime(2026, 1, 1),+ updated_at=datetime(2026, 1, 2),+ doc_metadata={},+ )+++def test_enable_built_in_field_uses_caller_session_for_uploader(sqlite_session: Session) -> None:+ dataset = _dataset(built_in_field_enabled=False)document = _document()+ sqlite_session.add_all([_account(), dataset, document])+ sqlite_session.commit()with (patch.object(MetadataService, "knowledge_base_metadata_lock_check"),patch.object(DocumentService, "get_working_documents_by_dataset_id", return_value=[document]),patch("services.metadata_service.redis_client.delete"),):- MetadataService.enable_built_in_field(dataset, session)+ MetadataService.enable_built_in_field(dataset, sqlite_session)- assert document.doc_metadata[BuiltInField.uploader] == "caller-session uploader"- document.get_uploader.assert_called_once_with(session=session)+ assert document.doc_metadata[BuiltInField.uploader] == "User"-def test_update_documents_metadata_uses_caller_session_for_uploader() -> None:- session = MagicMock()- dataset = MagicMock(id="dataset-1", tenant_id="tenant-1", built_in_field_enabled=True)+def test_update_documents_metadata_uses_caller_session_for_uploader(sqlite_session: Session) -> None:+ dataset = _dataset(built_in_field_enabled=True)document = _document()+ sqlite_session.add_all([_account(), dataset, document])+ sqlite_session.commit()metadata_args = MetadataOperationData(operation_data=[DocumentMetadataOperation(document_id=document.id, metadata_list=[], partial_update=False),@@ -85,23 +107,38 @@ def test_update_documents_metadata_uses_caller_session_for_uploader() -> None:metadata_args,_account(),"tenant-1",- session=session,+ session=sqlite_session,)- assert document.doc_metadata[BuiltInField.uploader] == "caller-session uploader"- document.get_uploader.assert_called_once_with(session=session)+ assert document.doc_metadata[BuiltInField.uploader] == "User"+++def test_get_dataset_metadatas_uses_caller_session(monkeypatch, sqlite_session: Session) -> None:+ dataset = _dataset(built_in_field_enabled=False)+ sqlite_session.add_all(+ [+ DatasetMetadataBinding(+ tenant_id="tenant-1",+ dataset_id="dataset-1",+ document_id=f"document-{index}",+ metadata_id="metadata-1",+ created_by="account-1",+ )+ for index in range(2)+ ]+ )+ sqlite_session.commit()+ def get_doc_metadata(_dataset: Dataset, *, session: Session) -> list[dict[str, str]]:+ assert session is sqlite_session+ return [{"id": "metadata-1", "name": "author", "type": "string"}]-def test_get_dataset_metadatas_uses_caller_session() -> None:- session = MagicMock()- session.scalar.return_value = 2- dataset = MagicMock(id="dataset-1", built_in_field_enabled=False)- dataset.get_doc_metadata.return_value = [{"id": "metadata-1", "name": "author", "type": "string"}]+ monkeypatch.setattr(Dataset, "get_doc_metadata", get_doc_metadata)- result = MetadataService.get_dataset_metadatas(dataset, session)+ result = MetadataService.get_dataset_metadatas(dataset, sqlite_session)assert result == {"doc_metadata": [{"id": "metadata-1", "name": "author", "type": "string", "count": 2}],"built_in_field_enabled": False,}- dataset.get_doc_metadata.assert_called_once_with(session=session)+ assert sqlite_session.scalar(select(DatasetMetadataBinding).limit(1)) is not Nonediff --git a/api/tests/unit_tests/services/test_workflow_service.py b/api/tests/unit_tests/services/test_workflow_service.pyindex 0843b04922e..9fdb2e07bc7 100644--- a/api/tests/unit_tests/services/test_workflow_service.py+++ b/api/tests/unit_tests/services/test_workflow_service.py@@ -16,7 +16,7 @@ from typing import Any, castfrom unittest.mock import ANY, MagicMock, patch, sentinelimport pytest-from sqlalchemy import select+from sqlalchemy import event, selectfrom sqlalchemy.dialects import postgresqlfrom sqlalchemy.engine import Enginefrom sqlalchemy.orm import Session, sessionmaker@@ -37,7 +37,6 @@ from graphon.variables import StringVariablefrom graphon.variables.input_entities import VariableEntityTypefrom libs.datetime_utils import naive_utc_nowfrom models.account import Account-from models.agent import WorkflowAgentNodeBindingfrom models.human_input import HumanInputFormRecipient, RecipientTypefrom models.model import App, AppModefrom models.tools import BuiltinToolProvider, WorkflowToolProvider@@ -201,11 +200,6 @@ class TestWorkflowAssociatedDataFactory:@pytest.mark.usefixtures("sqlite_session")- "sqlite_session",- [(Workflow, App, WorkflowToolProvider, HumanInputFormRecipient, WorkflowAgentNodeBinding)],- indirect=True,-)class TestWorkflowService:"""Comprehensive unit tests for WorkflowService methods.@@ -452,7 +446,7 @@ class TestWorkflowService:assert workflow.updated_by == account.iddef test_sync_draft_workflow_collaborative_save_preserves_environment_variables_and_locks_row(- self, workflow_service: WorkflowService+ self, workflow_service: WorkflowService, sqlite_session: Session) -> None:"""A collaborative graph-only save locks the draft and keeps server environment values."""app = TestWorkflowAssociatedDataFactory.create_app()@@ -466,9 +460,19 @@ class TestWorkflowService:)stale_variable = remote_variable.model_copy(update={"value": "stale-client-value"})workflow.environment_variables = [remote_variable]+ sqlite_session.add(workflow)+ sqlite_session.commit()unique_hash = workflow.unique_hash- session = MagicMock(spec=Session)- session.scalar.return_value = workflow+ statements = []+ commits = []++ @event.listens_for(sqlite_session, "do_orm_execute")+ def capture_statement(execute_state):+ statements.append(execute_state.statement)++ @event.listens_for(sqlite_session, "before_commit")+ def capture_commit(_session):+ commits.append(True)result = workflow_service.sync_draft_workflow(app_model=app,@@ -478,16 +482,15 @@ class TestWorkflowService:account=account,environment_variables=[stale_variable],conversation_variables=[],- session=session,+ session=sqlite_session,preserve_environment_variables=True,commit=False,sync_agent_bindings=False,)- statement = session.scalar.call_args.args[0]- assert "FOR UPDATE" in str(statement.compile(dialect=postgresql.dialect()))+ assert "FOR UPDATE" in str(statements[0].compile(dialect=postgresql.dialect()))assert result.environment_variables == [remote_variable]- session.commit.assert_not_called()+ assert commits == []def test_sync_draft_workflow_merges_environment_patch_with_graph_update(self, workflow_service: WorkflowService, sqlite_session: Session@@ -910,27 +913,31 @@ class TestWorkflowService:assert persisted_workflow.updated_by == account.iddef test_patch_draft_workflow_environment_variables_locks_draft_row(- self, workflow_service: WorkflowService+ self, workflow_service: WorkflowService, sqlite_session: Session) -> None:"""The merge reads the draft with a row lock before applying a partial update."""app = TestWorkflowAssociatedDataFactory.create_app()account = TestWorkflowAssociatedDataFactory.create_account()workflow = TestWorkflowAssociatedDataFactory.create_workflow()- session = MagicMock(spec=Session)- session.scalar.return_value = workflow+ sqlite_session.add(workflow)+ sqlite_session.commit()+ statements = []++ @event.listens_for(sqlite_session, "do_orm_execute")+ def capture_statement(execute_state):+ statements.append(execute_state.statement)workflow_service.patch_draft_workflow_environment_variables(app_model=app,environment_variables=[],deleted_environment_variable_ids=[],account=account,- session=session,+ session=sqlite_session,)- statement = session.scalar.call_args.args[0]- compiled_statement = str(statement.compile(dialect=postgresql.dialect()))+ compiled_statement = str(statements[0].compile(dialect=postgresql.dialect()))assert "FOR UPDATE" in compiled_statement- session.commit.assert_called_once_with()+ assert sqlite_session.get(Workflow, workflow.id) is workflowdef test_patch_draft_workflow_environment_variables_rejects_conflicting_ids(self, workflow_service: WorkflowService, sqlite_session: Session@@ -1670,7 +1677,6 @@ class TestWorkflowService:@pytest.mark.usefixtures("sqlite_session")[email protected]("sqlite_session", [(BuiltinToolProvider,)], indirect=True)class TestWorkflowServiceCredentialValidation:"""Tests for the private credential-validation helpers on WorkflowService.@@ -1779,7 +1785,7 @@ class TestWorkflowServiceCredentialValidation:mock_llm.assert_called_once_with("tenant-1", "openai", "gpt-4")def test_validate_workflow_credentials_should_use_llm_environment_variable_model(- self, service: WorkflowService+ self, service: WorkflowService, sqlite_session: Session) -> None:workflow = self._make_workflow([@@ -1814,7 +1820,7 @@ class TestWorkflowServiceCredentialValidation:patch.object(service, "_validate_llm_model_config") as validate_model,patch.object(service, "_validate_load_balancing_credentials") as validate_load_balancing,):- service._validate_workflow_credentials(workflow, session=MagicMock())+ service._validate_workflow_credentials(workflow, session=sqlite_session)validate_model.assert_called_once_with("tenant-1", "new-provider", "new-model")validated_node_data = validate_load_balancing.call_args.args[1]@@ -1826,7 +1832,7 @@ class TestWorkflowServiceCredentialValidation:}def test_validate_workflow_credentials_should_reject_llm_environment_variable_mode_mismatch(- self, service: WorkflowService+ self, service: WorkflowService, sqlite_session: Session) -> None:workflow = self._make_workflow([@@ -1848,7 +1854,7 @@ class TestWorkflowServiceCredentialValidation:]with pytest.raises(ValueError, match="uses mode 'completion'.*uses mode 'chat'"):- service._validate_workflow_credentials(workflow, session=MagicMock())+ service._validate_workflow_credentials(workflow, session=sqlite_session)def test_validate_workflow_credentials_should_raise_for_llm_node_missing_model(self, service: WorkflowService, sqlite_session: Session@@ -2964,7 +2970,6 @@ class TestWorkflowServiceHumanInputOperations:},)- @pytest.mark.parametrize("sqlite_session", [(Workflow,)], indirect=True)def test_get_human_input_form_preview_should_raise_if_workflow_not_init(self, service: WorkflowService, sqlite_session: Session) -> None:@@ -2977,7 +2982,6 @@ class TestWorkflowServiceHumanInputOperations:session=sqlite_session,)- @pytest.mark.parametrize("sqlite_session", [(Workflow,)], indirect=True)def test_get_human_input_form_preview_should_raise_if_wrong_node_type(self, service: WorkflowService, sqlite_session: Session) -> None:@@ -2993,7 +2997,6 @@ class TestWorkflowServiceHumanInputOperations:session=sqlite_session,)- @pytest.mark.parametrize("sqlite_session", [(Workflow,)], indirect=True)def test_get_human_input_form_preview_success(self, service: WorkflowService, sqlite_session: Session) -> None:app_model = TestWorkflowAssociatedDataFactory.create_app(app_id="app-1", tenant_id="tenant-1")account = TestWorkflowAssociatedDataFactory.create_account(account_id="user-1")@@ -3017,7 +3020,6 @@ class TestWorkflowServiceHumanInputOperations:mock_node.render_form_content_before_submission.assert_called_once()mock_required_cls.return_value.model_dump.assert_called_once()- @pytest.mark.parametrize("sqlite_session", [(Workflow,)], indirect=True)def test_submit_human_input_form_preview_success(self, service: WorkflowService, sqlite_session: Session) -> None:app_model = TestWorkflowAssociatedDataFactory.create_app(app_id="app-1", tenant_id="tenant-1")account = TestWorkflowAssociatedDataFactory.create_account(account_id="user-1")@@ -3058,7 +3060,6 @@ class TestWorkflowServiceHumanInputOperations:assert result["__rendered_content"] == "Ticket: val1"mock_saver_cls.return_value.save.assert_called_once()- @pytest.mark.parametrize("sqlite_session", [(Workflow,)], indirect=True)def test_test_human_input_delivery_success(self, service: WorkflowService, sqlite_session: Session) -> None:draft = self._create_human_input_workflow()service.get_draft_workflow = MagicMock(return_value=draft)@@ -3082,7 +3083,6 @@ class TestWorkflowServiceHumanInputOperations:)mock_test_srv.return_value.send_test.assert_called_once()- @pytest.mark.parametrize("sqlite_session", [(Workflow,)], indirect=True)def test_test_human_input_delivery_failure_cases(self, service: WorkflowService, sqlite_session: Session) -> None:draft = self._create_human_input_workflow()service.get_draft_workflow = MagicMock(return_value=draft)@@ -3100,7 +3100,6 @@ class TestWorkflowServiceHumanInputOperations:session=sqlite_session,)- @pytest.mark.parametrize("sqlite_session", [(HumanInputFormRecipient,)], indirect=True)def test_load_email_recipients_parsing_failure(self, service: WorkflowService, sqlite_session: Session) -> None:"""Malformed persisted recipient payloads are skipped instead of aborting delivery tests."""recipient = HumanInputFormRecipient(diff --git a/api/tests/unit_tests/services/workflow/test_workflow_converter_additional.py b/api/tests/unit_tests/services/workflow/test_workflow_converter_additional.pyindex 60c8b5213f6..706ea415e2a 100644--- a/api/tests/unit_tests/services/workflow/test_workflow_converter_additional.py+++ b/api/tests/unit_tests/services/workflow/test_workflow_converter_additional.py@@ -6,6 +6,8 @@ from typing import Any, castfrom unittest.mock import MagicMock, callimport pytest+from sqlalchemy import event, select+from sqlalchemy.orm import Sessionfrom core.app.app_config.entities import (AdvancedChatMessageEntity,@@ -20,7 +22,8 @@ from core.app.app_config.entities import (from core.helper import encrypterfrom core.prompt.utils.prompt_template_parser import PromptTemplateParserfrom models.api_based_extension import APIBasedExtension, APIBasedExtensionPoint-from models.model import Account, App, AppMode, AppModelConfig+from models.model import Account, App, AppMode, AppModelConfig, IconType+from models.workflow import Workflow, WorkflowTypefrom services.workflow import workflow_converter as converter_modulefrom services.workflow.workflow_converter import WorkflowConverter@@ -88,7 +91,9 @@ def test__convert_to_start_node(default_variables: list[VariableEntity]) -> Noneassert result["data"]["variables"][0]["variable"] == "text_input"-def test__convert_to_http_request_node_for_chatbot(default_variables: list[VariableEntity]) -> None:+def test__convert_to_http_request_node_for_chatbot(+ default_variables: list[VariableEntity], unbound_session: Session+) -> None:app_model = MagicMock()app_model.id = "app_id"app_model.tenant_id = "tenant_id"@@ -118,7 +123,7 @@ def test__convert_to_http_request_node_for_chatbot(default_variables: list[Variaapp_model=app_model,variables=default_variables,external_data_variables=external_data_variables,- session=MagicMock(),+ session=unbound_session,)assert len(nodes) == 2@@ -131,7 +136,9 @@ def test__convert_to_http_request_node_for_chatbot(default_variables: list[Variaassert mapping == {"external_variable": "code_1"}-def test__convert_to_http_request_node_for_workflow_app(default_variables: list[VariableEntity]) -> None:+def test__convert_to_http_request_node_for_workflow_app(+ default_variables: list[VariableEntity], unbound_session: Session+) -> None:app_model = MagicMock()app_model.id = "app_id"app_model.tenant_id = "tenant_id"@@ -161,7 +168,7 @@ def test__convert_to_http_request_node_for_workflow_app(default_variables: list[app_model=app_model,variables=default_variables,external_data_variables=external_data_variables,- session=MagicMock(),+ session=unbound_session,)body = json.loads(nodes[0]["data"]["body"]["data"])@@ -355,9 +362,10 @@ def test__convert_to_answer_node() -> None:assert node["data"]["type"] == BuiltinNodeTypes.ANSWER-def test_convert_to_workflow_should_raise_when_app_model_config_is_missing(converter: WorkflowConverter) -> None:+def test_convert_to_workflow_should_raise_when_app_model_config_is_missing(+ converter: WorkflowConverter, unbound_session: Session+) -> None:app_model = _app_model(app_model_config_id=None)- session = MagicMock()with pytest.raises(ValueError, match="App model config is required"):converter.convert_to_workflow(@@ -367,10 +375,10 @@ def test_convert_to_workflow_should_raise_when_app_model_config_is_missing(conveicon_type="emoji",icon="robot",icon_background="#fff",- session=session,+ session=unbound_session,)- session.get.assert_not_called()+ assert not unbound_session.in_transaction()@pytest.mark.parametrize(@@ -385,23 +393,26 @@ def test_convert_to_workflow_should_create_new_app_with_fallback_fields(monkeypatch: pytest.MonkeyPatch,source_mode: AppMode,expected_mode: AppMode,+ sqlite_session: Session,) -> None:- class FakeApp:- def __init__(self) -> None:- self.id = "new-app-id"-- workflow = SimpleNamespace(app_id=None)+ app_model_config = AppModelConfig(app_id="source-app")+ app_model_config.id = "config-1"+ sqlite_session.add(app_model_config)+ sqlite_session.flush()+ workflow = Workflow(+ tenant_id="tenant-1",+ app_id="source-app",+ type=WorkflowType.WORKFLOW,+ version=Workflow.VERSION_DRAFT,+ graph="{}",+ features="{}",+ created_by="account-1",+ environment_variables=[],+ conversation_variables=[],+ )monkeypatch.setattr(converter, "convert_app_model_config_to_workflow", MagicMock(return_value=workflow))- monkeypatch.setattr(converter_module, "App", FakeApp)-- app_model_config = _app_model_config(id="config-1")phase_events: list[str] = []- db_session = SimpleNamespace(- add=MagicMock(),- flush=MagicMock(),- commit=MagicMock(side_effect=lambda: phase_events.append("commit")),- get=MagicMock(return_value=app_model_config),- )+ event.listen(sqlite_session, "after_commit", lambda _session: phase_events.append("commit"))send_mock = MagicMock(side_effect=lambda *_args, **_kwargs: phase_events.append("signal"))monkeypatch.setattr(converter_module.app_was_created, "send", send_mock)@@ -409,9 +420,10 @@ def test_convert_to_workflow_should_create_new_app_with_fallback_fields(account = _account(id="account-1")app_model = _app_model(tenant_id="tenant-1",+ id="source-app",name="Source App",mode=source_mode,- icon_type="emoji",+ icon_type=IconType.EMOJI,icon="sparkles",icon_background="#123456",enable_site=True,@@ -429,27 +441,25 @@ def test_convert_to_workflow_should_create_new_app_with_fallback_fields(icon_type="",icon="",icon_background="",- session=db_session,+ session=sqlite_session,)assert new_app.name == "Source App(workflow)"assert new_app.mode == expected_mode- assert new_app.icon_type == "emoji"+ assert new_app.icon_type == IconType.EMOJIassert new_app.icon == "sparkles"assert new_app.icon_background == "#123456"assert new_app.created_by == "account-1"- assert workflow.app_id == "new-app-id"- db_session.add.assert_called_once()- db_session.flush.assert_called_once()+ assert workflow.app_id == new_app.id+ assert sqlite_session.get(App, new_app.id) is new_appassert phase_events == ["commit", "signal", "commit"]- assert db_session.commit.call_count == 2- db_session.get.assert_called_once_with(AppModelConfig, "config-1")- send_mock.assert_called_once_with(new_app, account=account, session=db_session)+ send_mock.assert_called_once_with(new_app, account=account, session=sqlite_session)def test_convert_app_model_config_to_workflow_should_build_advanced_chat_graph_and_features(converter: WorkflowConverter,monkeypatch: pytest.MonkeyPatch,+ sqlite_session: Session,) -> None:app_model = _app_model(id="app-1", tenant_id="tenant-1", mode=AppMode.CHAT)app_config = SimpleNamespace(@@ -471,12 +481,6 @@ def test_convert_app_model_config_to_workflow_should_build_advanced_chat_graph_a},)- class FakeWorkflow:- VERSION_DRAFT = "draft"-- def __init__(self, **kwargs: Any) -> None:- self.__dict__.update(kwargs)-monkeypatch.setattr(converter, "_get_new_app_mode", MagicMock(return_value=AppMode.ADVANCED_CHAT))monkeypatch.setattr(converter, "_convert_to_app_config", MagicMock(return_value=app_config))monkeypatch.setattr(@@ -513,15 +517,11 @@ def test_convert_app_model_config_to_workflow_should_build_advanced_chat_graph_a"_convert_to_answer_node",MagicMock(return_value={"id": "answer", "position": None, "data": {"type": BuiltinNodeTypes.ANSWER}}),)- monkeypatch.setattr(converter_module, "Workflow", FakeWorkflow)-- db_session = SimpleNamespace(add=MagicMock(), commit=MagicMock())-workflow = converter.convert_app_model_config_to_workflow(app_model=app_model,app_model_config=_app_model_config(id="cfg"),account_id="account-1",- session=db_session,+ session=sqlite_session,)graph = json.loads(workflow.graph)@@ -531,13 +531,13 @@ def test_convert_app_model_config_to_workflow_should_build_advanced_chat_graph_afeatures = json.loads(workflow.features)assert "opening_statement" in featuresassert "retriever_resource" in features- db_session.add.assert_called_once()- db_session.commit.assert_called_once()+ assert sqlite_session.scalar(select(Workflow).where(Workflow.id == workflow.id)) is workflowdef test_convert_app_model_config_to_workflow_should_build_workflow_mode_with_end_node(converter: WorkflowConverter,monkeypatch: pytest.MonkeyPatch,+ sqlite_session: Session,) -> None:app_model = _app_model(id="app-1", tenant_id="tenant-1", mode=AppMode.COMPLETION)app_config = SimpleNamespace(@@ -554,12 +554,6 @@ def test_convert_app_model_config_to_workflow_should_build_workflow_mode_with_en},)- class FakeWorkflow:- VERSION_DRAFT = "draft"-- def __init__(self, **kwargs: Any) -> None:- self.__dict__.update(kwargs)-monkeypatch.setattr(converter, "_get_new_app_mode", MagicMock(return_value=AppMode.WORKFLOW))monkeypatch.setattr(converter, "_convert_to_app_config", MagicMock(return_value=app_config))monkeypatch.setattr(@@ -580,15 +574,11 @@ def test_convert_app_model_config_to_workflow_should_build_workflow_mode_with_en"_convert_to_end_node",MagicMock(return_value={"id": "end", "position": None, "data": {"type": BuiltinNodeTypes.END}}),)- monkeypatch.setattr(converter_module, "Workflow", FakeWorkflow)-- db_session = SimpleNamespace(add=MagicMock(), commit=MagicMock())-workflow = converter.convert_app_model_config_to_workflow(app_model=app_model,app_model_config=_app_model_config(id="cfg"),account_id="account-1",- session=db_session,+ session=sqlite_session,)graph = json.loads(workflow.graph)@@ -597,11 +587,13 @@ def test_convert_app_model_config_to_workflow_should_build_workflow_mode_with_enfeatures = json.loads(workflow.features)assert set(features.keys()) == {"text_to_speech", "file_upload", "sensitive_word_avoidance"}+ assert sqlite_session.scalar(select(Workflow).where(Workflow.id == workflow.id)) is workflowdef test_convert_to_app_config_should_route_to_correct_manager(converter: WorkflowConverter,monkeypatch: pytest.MonkeyPatch,+ unbound_session: Session,) -> None:agent_result = SimpleNamespace(kind="agent")chat_result = SimpleNamespace(kind="chat")@@ -614,7 +606,6 @@ def test_convert_to_app_config_should_route_to_correct_manager(monkeypatch.setattr(converter_module.ChatAppConfigManager, "get_app_config", chat_get_app_config)monkeypatch.setattr(converter_module.CompletionAppConfigManager, "get_app_config", completion_get_app_config)monkeypatch.setattr(converter_module, "load_annotation_reply_config", load_annotation_reply)- session = MagicMock()agent_mode_app = _app_model(mode=AppMode.AGENT_CHAT, is_agent_with_session=MagicMock(return_value=False))agent_flag_app = _app_model(mode=AppMode.CHAT, is_agent_with_session=MagicMock(return_value=True))chat_app = _app_model(mode=AppMode.CHAT, is_agent_with_session=MagicMock(return_value=False))@@ -627,31 +618,36 @@ def test_convert_to_app_config_should_route_to_correct_manager(from_agent_mode = converter._convert_to_app_config(app_model=agent_mode_app,app_model_config=agent_mode_config,- session=session,+ session=unbound_session,)from_agent_flag = converter._convert_to_app_config(app_model=agent_flag_app,app_model_config=agent_flag_config,- session=session,+ session=unbound_session,)from_chat_mode = converter._convert_to_app_config(app_model=chat_app,app_model_config=chat_config,- session=session,+ session=unbound_session,)from_completion_mode = converter._convert_to_app_config(app_model=completion_app,app_model_config=completion_config,- session=session,+ session=unbound_session,)assert from_agent_mode is agent_resultassert from_agent_flag is agent_resultassert from_chat_mode is chat_resultassert from_completion_mode is completion_result- agent_flag_app.is_agent_with_session.assert_called_once_with(session=session)+ agent_flag_app.is_agent_with_session.assert_called_once_with(session=unbound_session)load_annotation_reply.assert_has_calls(- [call(session, "app-1"), call(session, "app-2"), call(session, "app-3"), call(session, "app-4")]+ [+ call(unbound_session, "app-1"),+ call(unbound_session, "app-2"),+ call(unbound_session, "app-3"),+ call(unbound_session, "app-4"),+ ])assert all(manager_call.kwargs["annotation_reply"] == {"enabled": False}@@ -660,18 +656,20 @@ def test_convert_to_app_config_should_route_to_correct_manager()-def test_convert_to_app_config_should_raise_for_invalid_app_mode(converter: WorkflowConverter) -> None:+def test_convert_to_app_config_should_raise_for_invalid_app_mode(+ converter: WorkflowConverter, unbound_session: Session+) -> None:app_model = _app_model(mode=AppMode.WORKFLOW, is_agent_with_session=MagicMock(return_value=False))- session = MagicMock()with pytest.raises(ValueError, match="Invalid app mode"):converter._convert_to_app_config(- app_model=app_model, app_model_config=_app_model_config(id="cfg"), session=session+ app_model=app_model, app_model_config=_app_model_config(id="cfg"), session=unbound_session)def test_convert_to_http_request_node_should_skip_non_api_and_missing_extension_id(converter: WorkflowConverter,+ unbound_session: Session,) -> None:app_model = _app_model(id="app-1", tenant_id="tenant-1", mode=AppMode.CHAT)external_data_variables = [@@ -683,7 +681,7 @@ def test_convert_to_http_request_node_should_skip_non_api_and_missing_extension_app_model=app_model,variables=[],external_data_variables=external_data_variables,- session=MagicMock(),+ session=unbound_session,)assert nodes == []diff --git a/api/tests/unit_tests/services/workflow/test_workflow_event_snapshot_service.py b/api/tests/unit_tests/services/workflow/test_workflow_event_snapshot_service.pyindex 63aa53c0bf6..642389fe035 100644--- a/api/tests/unit_tests/services/workflow/test_workflow_event_snapshot_service.py+++ b/api/tests/unit_tests/services/workflow/test_workflow_event_snapshot_service.py@@ -720,6 +720,7 @@ def test_start_buffering_should_set_done_event_when_subscription_raises() -> Nondef test_build_workflow_event_stream_should_emit_ping_and_terminal_snapshot_event(monkeypatch: pytest.MonkeyPatch,+ unbound_session_factory: sessionmaker[Session],) -> None:# Arrangeworkflow_run = _build_workflow_run_additional(status=WorkflowExecutionStatus.PAUSED)@@ -764,7 +765,7 @@ def test_build_workflow_event_stream_should_emit_ping_and_terminal_snapshot_even"_build_snapshot_events",MagicMock(return_value=[{"event": StreamEvent.WORKFLOW_FINISHED, "task_id": "task-1"}]),)- session_maker = MagicMock()+ session_maker = unbound_session_factory# Actevents = list(@@ -817,6 +818,7 @@ def test_build_workflow_event_stream_should_emit_ping_and_terminal_snapshot_even)def test_build_advanced_chat_snapshot_requires_conversation_context(monkeypatch: pytest.MonkeyPatch,+ unbound_session_factory: sessionmaker[Session],resumption_context: WorkflowResumptionContext | None,expected_error: str,) -> None:@@ -848,7 +850,7 @@ def test_build_advanced_chat_snapshot_requires_conversation_context(workflow_run=workflow_run,tenant_id="tenant-1",app_id="app-1",- session_maker=MagicMock(),+ session_maker=unbound_session_factory,)conversation_lookup.assert_not_called()app_lookup.assert_not_called()@@ -856,6 +858,7 @@ def test_build_advanced_chat_snapshot_requires_conversation_context(def test_build_non_suspended_advanced_chat_snapshot_uses_app_scoped_fallback(monkeypatch: pytest.MonkeyPatch,+ unbound_session_factory: sessionmaker[Session],) -> None:# Arrangeworkflow_run = _build_workflow_run_additional(status=WorkflowExecutionStatus.RUNNING)@@ -877,7 +880,7 @@ def test_build_non_suspended_advanced_chat_snapshot_uses_app_scoped_fallback(conversation_lookup,)monkeypatch.setattr(service_module, "_get_message_context_by_app", app_lookup)- session_maker = MagicMock()+ session_maker = unbound_session_factory# Actevent_stream = build_workflow_event_stream(