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 remaining controller sessions and ORM models to SQLite (#40538)
Asuka Minato92b93c9d3788
diff --git a/api/tests/unit_tests/controllers/console/app/test_agent_manage_guard.py b/api/tests/unit_tests/controllers/console/app/test_agent_manage_guard.pyindex 4d627354908..a261f4c998b 100644--- a/api/tests/unit_tests/controllers/console/app/test_agent_manage_guard.py+++ b/api/tests/unit_tests/controllers/console/app/test_agent_manage_guard.py@@ -1,16 +1,17 @@-from types import SimpleNamespace-from unittest.mock import MagicMock, patch+from unittest.mock import patchimport pytest+from sqlalchemy.orm import Session, scoped_session, sessionmakerfrom werkzeug.exceptions import Forbiddenfrom controllers.console.app.error import AppNotFoundErrorfrom controllers.console.app.wraps import agent_manage_required_for_agent_appfrom core.rbac import RBACPermission, RBACResourceScope-from models.agent import AgentScope+from models import Account+from models.agent import Agent, AgentScope, AgentSource, AgentStatus+from models.model import App, AppModeTENANT_ID = "tenant-1"-ACCOUNT = SimpleNamespace(id="account-1")def _guarded_view():@@ -24,28 +25,64 @@ def _guarded_view():return view, calls-def _app_with_binding(binding):- app_model = MagicMock()- app_model.agent_app_binding_with_session.return_value = binding+def _persist_app(+ session: Session,+ *,+ scope: AgentScope | None = None,+ status: AgentStatus = AgentStatus.ACTIVE,+) -> App:+ app_model = App(+ id="app-1",+ tenant_id=TENANT_ID,+ name="Managed App",+ mode=AppMode.AGENT if scope is not None else AppMode.CHAT,+ enable_site=True,+ enable_api=False,+ )+ session.add(app_model)+ if scope is not None:+ agent = Agent(+ tenant_id=TENANT_ID,+ name=f"{scope.value} agent",+ scope=scope,+ source=AgentSource.AGENT_APP if scope == AgentScope.ROSTER else AgentSource.WORKFLOW,+ status=status,+ app_id=app_model.id if scope == AgentScope.ROSTER else None,+ backing_app_id=app_model.id if scope == AgentScope.WORKFLOW_ONLY else None,+ )+ session.add(agent)+ session.commit()return app_model-def _patch_guard(app_model, rbac_enabled: bool):- mock_db = MagicMock()- mock_db.session.scalar.return_value = app_model+def _patch_guard(account: Account, rbac_enabled: bool):return (- patch("controllers.console.app.wraps.db", mock_db),- patch("controllers.console.app.wraps.current_account_with_tenant", return_value=(ACCOUNT, TENANT_ID)),+ patch("controllers.console.app.wraps.current_account_with_tenant", return_value=(account, TENANT_ID)),patch("controllers.console.app.wraps.dify_config.RBAC_ENABLED", rbac_enabled),)class TestAgentManageRequiredForAgentApp:+ @pytest.fixture(autouse=True)+ def _bind_database(+ self,+ sqlite_session: Session,+ sqlite_session_factory: sessionmaker[Session],+ ):+ self.sqlite_session = sqlite_session+ self.account = Account(name="Guard User", email="[email protected]")+ self.account.id = "account-1"+ session_proxy = scoped_session(sqlite_session_factory)+ with patch("controllers.console.app.wraps.db.session", session_proxy):+ yield+ session_proxy.remove()+def test_non_agent_app_passes_through_without_workspace_check(self):view, calls = _guarded_view()- patches = _patch_guard(_app_with_binding(None), rbac_enabled=True)+ _persist_app(self.sqlite_session)+ patches = _patch_guard(self.account, rbac_enabled=True)- with patches[0], patches[1], patches[2], patch("controllers.console.app.wraps.enforce_rbac_access") as gate:+ with patches[0], patches[1], patch("controllers.console.app.wraps.enforce_rbac_access") as gate:assert view(app_id="app-1") == "ok"gate.assert_not_called()@@ -53,15 +90,15 @@ class TestAgentManageRequiredForAgentApp:def test_roster_agent_app_requires_agent_manage_when_rbac_enabled(self):view, _ = _guarded_view()- binding = SimpleNamespace(scope=AgentScope.ROSTER)- patches = _patch_guard(_app_with_binding(binding), rbac_enabled=True)+ _persist_app(self.sqlite_session, scope=AgentScope.ROSTER)+ patches = _patch_guard(self.account, rbac_enabled=True)- with patches[0], patches[1], patches[2], patch("controllers.console.app.wraps.enforce_rbac_access") as gate:+ with patches[0], patches[1], patch("controllers.console.app.wraps.enforce_rbac_access") as gate:assert view(app_id="app-1") == "ok"gate.assert_called_once_with(tenant_id=TENANT_ID,- account_id=ACCOUNT.id,+ account_id=self.account.id,resource_type=RBACResourceScope.WORKSPACE,scene=RBACPermission.AGENT_MANAGE,resource_required=False,@@ -69,13 +106,12 @@ class TestAgentManageRequiredForAgentApp:def test_roster_agent_app_denied_without_agent_manage(self):view, calls = _guarded_view()- binding = SimpleNamespace(scope=AgentScope.ROSTER)- patches = _patch_guard(_app_with_binding(binding), rbac_enabled=True)+ _persist_app(self.sqlite_session, scope=AgentScope.ROSTER)+ patches = _patch_guard(self.account, rbac_enabled=True)with (patches[0],patches[1],- patches[2],patch("controllers.console.app.wraps.enforce_rbac_access", side_effect=Forbidden()),):with pytest.raises(Forbidden):@@ -85,10 +121,10 @@ class TestAgentManageRequiredForAgentApp:def test_roster_agent_app_skips_workspace_check_when_rbac_disabled(self):view, _ = _guarded_view()- binding = SimpleNamespace(scope=AgentScope.ROSTER)- patches = _patch_guard(_app_with_binding(binding), rbac_enabled=False)+ _persist_app(self.sqlite_session, scope=AgentScope.ROSTER)+ patches = _patch_guard(self.account, rbac_enabled=False)- with patches[0], patches[1], patches[2], patch("controllers.console.app.wraps.enforce_rbac_access") as gate:+ with patches[0], patches[1], patch("controllers.console.app.wraps.enforce_rbac_access") as gate:assert view(app_id="app-1") == "ok"gate.assert_not_called()@@ -96,10 +132,10 @@ class TestAgentManageRequiredForAgentApp:def test_hidden_backing_app_is_rejected_even_without_rbac(self):"""A workflow-only backing App is not part of the general app management plane."""view, calls = _guarded_view()- binding = SimpleNamespace(scope=AgentScope.WORKFLOW_ONLY)- patches = _patch_guard(_app_with_binding(binding), rbac_enabled=False)+ _persist_app(self.sqlite_session, scope=AgentScope.WORKFLOW_ONLY)+ patches = _patch_guard(self.account, rbac_enabled=False)- with patches[0], patches[1], patches[2]:+ with patches[0], patches[1]:with pytest.raises(AppNotFoundError):view(app_id="app-1")@@ -107,10 +143,10 @@ class TestAgentManageRequiredForAgentApp:def test_hidden_backing_app_is_rejected_before_workspace_check(self):view, calls = _guarded_view()- binding = SimpleNamespace(scope=AgentScope.WORKFLOW_ONLY)- patches = _patch_guard(_app_with_binding(binding), rbac_enabled=True)+ _persist_app(self.sqlite_session, scope=AgentScope.WORKFLOW_ONLY)+ patches = _patch_guard(self.account, rbac_enabled=True)- with patches[0], patches[1], patches[2], patch("controllers.console.app.wraps.enforce_rbac_access") as gate:+ with patches[0], patches[1], patch("controllers.console.app.wraps.enforce_rbac_access") as gate:with pytest.raises(AppNotFoundError):view(app_id="app-1")@@ -120,30 +156,29 @@ class TestAgentManageRequiredForAgentApp:def test_binding_lookup_covers_archived_agents(self):"""An Agent App stays gated after its roster Agent is archived."""view, _ = _guarded_view()- app_model = _app_with_binding(SimpleNamespace(scope=AgentScope.ROSTER))- patches = _patch_guard(app_model, rbac_enabled=True)+ _persist_app(self.sqlite_session, scope=AgentScope.ROSTER, status=AgentStatus.ARCHIVED)+ patches = _patch_guard(self.account, rbac_enabled=True)- with patches[0], patches[1], patches[2], patch("controllers.console.app.wraps.enforce_rbac_access"):+ with patches[0], patches[1], patch("controllers.console.app.wraps.enforce_rbac_access") as gate:view(app_id="app-1")- _, call_kwargs = app_model.agent_app_binding_with_session.call_args- assert call_kwargs["include_archived"] is True+ gate.assert_called_once()def test_resource_id_path_alias_is_resolved(self):view, _ = _guarded_view()- binding = SimpleNamespace(scope=AgentScope.ROSTER)- patches = _patch_guard(_app_with_binding(binding), rbac_enabled=True)+ _persist_app(self.sqlite_session, scope=AgentScope.ROSTER)+ patches = _patch_guard(self.account, rbac_enabled=True)- with patches[0], patches[1], patches[2], patch("controllers.console.app.wraps.enforce_rbac_access") as gate:+ with patches[0], patches[1], patch("controllers.console.app.wraps.enforce_rbac_access") as gate:assert view(resource_id="app-1") == "ok"gate.assert_called_once()def test_unknown_app_passes_through_for_downstream_handling(self):view, calls = _guarded_view()- patches = _patch_guard(None, rbac_enabled=True)+ patches = _patch_guard(self.account, rbac_enabled=True)- with patches[0], patches[1], patches[2], patch("controllers.console.app.wraps.enforce_rbac_access") as gate:+ with patches[0], patches[1], patch("controllers.console.app.wraps.enforce_rbac_access") as gate:assert view(app_id="app-1") == "ok"gate.assert_not_called()diff --git a/api/tests/unit_tests/controllers/console/test_wraps.py b/api/tests/unit_tests/controllers/console/test_wraps.pyindex 37b1f0782c2..d151a8d4c30 100644--- a/api/tests/unit_tests/controllers/console/test_wraps.py+++ b/api/tests/unit_tests/controllers/console/test_wraps.py@@ -40,7 +40,7 @@ from enums import DeploymentEditionfrom libs.login import AccountWithTenantfrom machinery.context import RequestContextfrom machinery.errors import ActiveWorkspaceRequiredError, AdmissionConfigurationError-from models import Account+from models import Account, DifySetupfrom models.account import AccountStatus, TenantAccountRolefrom models.dataset import Dataset, RateLimitLogfrom services.entities.feature_entities import LicenseStatus@@ -980,61 +980,69 @@ class TestCloudUtmRecord:class TestSystemSetup:"""Test system setup decorator"""- @patch("controllers.console.wraps.db")- def test_should_allow_when_setup_complete(self, mock_db: MagicMock):+ @staticmethod+ def _complete_setup(session: Session) -> DifySetup:+ setup = DifySetup(version="1.0")+ session.add(setup)+ session.commit()+ return setup++ def test_should_allow_when_setup_complete(self, sqlite_session: Session):"""Test that requests are allowed when setup is complete"""- # Arrange+ self._complete_setup(sqlite_session)@setup_requireddef admin_view():return "admin_success"# Act- with patch("controllers.console.wraps.dify_config.DEPLOYMENT_EDITION", DeploymentEdition.COMMUNITY):+ with (+ patch("controllers.console.wraps.db.session", sqlite_session),+ patch("controllers.console.wraps.dify_config.DEPLOYMENT_EDITION", DeploymentEdition.COMMUNITY),+ ):result = admin_view()# Assertassert result == "admin_success"- @patch("controllers.console.wraps.db")- def test_should_cache_completed_setup(self, mock_db):+ def test_should_cache_completed_setup(self, sqlite_session: Session):"""Test that completed setup skips repeated DB reads in this process"""- mock_db.session.scalar.return_value = MagicMock()+ setup = self._complete_setup(sqlite_session)@setup_requireddef admin_view():return "admin_success"- with patch("controllers.console.wraps.dify_config.DEPLOYMENT_EDITION", DeploymentEdition.COMMUNITY):+ with (+ patch("controllers.console.wraps.db.session", sqlite_session),+ patch("controllers.console.wraps.dify_config.DEPLOYMENT_EDITION", DeploymentEdition.COMMUNITY),+ ):assert admin_view() == "admin_success"+ sqlite_session.delete(setup)+ sqlite_session.commit()assert admin_view() == "admin_success"- assert mock_db.session.scalar.call_count == 1+ assert sqlite_session.get(DifySetup, "1.0") is None- @patch("controllers.console.wraps.db")- def test_should_not_cache_missing_setup(self, mock_db):+ def test_should_not_cache_missing_setup(self, sqlite_session: Session):"""Test that first-time bootstrap completion can be observed later in the same process"""- mock_db.session.scalar.side_effect = [None, MagicMock()]@setup_requireddef admin_view():return "admin_success"with (+ patch("controllers.console.wraps.db.session", sqlite_session),patch("controllers.console.wraps.dify_config.DEPLOYMENT_EDITION", DeploymentEdition.COMMUNITY),patch("controllers.console.wraps.dify_config.INIT_PASSWORD", ""),):with pytest.raises(NotSetupError):admin_view()+ self._complete_setup(sqlite_session)assert admin_view() == "admin_success"- assert mock_db.session.scalar.call_count == 2-- @patch("controllers.console.wraps.db")- def test_should_raise_not_init_validate_error_with_init_password(self, mock_db: MagicMock):+ def test_should_raise_not_init_validate_error_with_init_password(self, sqlite_session: Session):"""Test NotInitValidateError when INIT_PASSWORD is set but setup not complete"""- # Arrange- mock_db.session.scalar.return_value = None # No setup@setup_requireddef admin_view():@@ -1042,17 +1050,15 @@ class TestSystemSetup:# Act & Assertwith (+ patch("controllers.console.wraps.db.session", sqlite_session),patch("controllers.console.wraps.dify_config.DEPLOYMENT_EDITION", DeploymentEdition.COMMUNITY),patch("controllers.console.wraps.dify_config.INIT_PASSWORD", "some_password"),):with pytest.raises(NotInitValidateError):admin_view()- @patch("controllers.console.wraps.db")- def test_should_raise_not_setup_error_without_init_password(self, mock_db: MagicMock):+ def test_should_raise_not_setup_error_without_init_password(self, sqlite_session: Session):"""Test NotSetupError when no INIT_PASSWORD and setup not complete"""- # Arrange- mock_db.session.scalar.return_value = None # No setup@setup_requireddef admin_view():@@ -1060,6 +1066,7 @@ class TestSystemSetup:# Act & Assertwith (+ patch("controllers.console.wraps.db.session", sqlite_session),patch("controllers.console.wraps.dify_config.DEPLOYMENT_EDITION", DeploymentEdition.COMMUNITY),patch("controllers.console.wraps.dify_config.INIT_PASSWORD", ""),):diff --git a/api/tests/unit_tests/controllers/inner_api/app/test_dsl.py b/api/tests/unit_tests/controllers/inner_api/app/test_dsl.pyindex c11a6a97302..94ea55375de 100644--- a/api/tests/unit_tests/controllers/inner_api/app/test_dsl.py+++ b/api/tests/unit_tests/controllers/inner_api/app/test_dsl.py@@ -13,7 +13,7 @@ from uuid import uuid4import pytestfrom flask import Flaskfrom pydantic import ValidationError-from sqlalchemy import event, select+from sqlalchemy import eventfrom sqlalchemy.engine import Enginefrom sqlalchemy.orm import Session, scoped_session, sessionmaker@@ -24,8 +24,8 @@ from controllers.inner_api.app.dsl import (InnerAppDSLImportPayload,_get_active_account,)-from models import Account, App-from models.account import AccountStatus+from models import Account, App, Tenant, TenantAccountJoin+from models.account import AccountStatus, TenantAccountRolefrom models.model import AppMode, IconTypefrom services.app_dsl_service import Import, ImportStatusfrom services.errors.app import IsDraftWorkflowError, WorkflowNotFoundError@@ -48,6 +48,24 @@ def _persist_app(session: Session) -> App:return app+def _persist_account(session: Session, *, workspace_id: str = "ws-123") -> Account:+ account = Account(name="DSL Creator", email="[email protected]", status=AccountStatus.ACTIVE)+ tenant = Tenant(name="DSL Workspace")+ tenant.id = workspace_id+ session.add_all([account, tenant])+ session.flush()+ session.add(+ TenantAccountJoin(+ tenant_id=tenant.id,+ account_id=account.id,+ current=True,+ role=TenantAccountRole.OWNER,+ )+ )+ session.commit()+ return account++class TestInnerAppDSLImportPayload:"""Test InnerAppDSLImportPayload Pydantic model validation."""@@ -160,9 +178,10 @@ class TestEnterpriseAppDSLImport:@pytest.mark.usefixtures("_mock_import_deps")@patch("controllers.inner_api.app.dsl._get_active_account")- def test_import_success_returns_200(self, mock_get_account, api_instance, app: Flask):- mock_account = MagicMock()- mock_get_account.return_value = mock_account+ def test_import_success_returns_200(self, mock_get_account, api_instance, app: Flask, sqlite_session: Session):+ account = _persist_account(sqlite_session)+ self._transaction_events.clear()+ mock_get_account.return_value = accountself._mock_dsl.import_app.return_value = self._make_import_result(ImportStatus.COMPLETED)unwrapped = inspect.unwrap(api_instance.post)@@ -177,14 +196,15 @@ class TestEnterpriseAppDSLImport:body, status_code = resultassert status_code == 200assert body["status"] == "completed"- call_session = mock_account.set_tenant_id_with_session.call_args.kwargs["session"]- assert isinstance(call_session, Session)+ assert account.current_tenant_id == "ws-123"+ assert self._mock_dsl.import_app.call_args.kwargs["account"] is accountassert self._transaction_events == ["commit"]@pytest.mark.usefixtures("_mock_import_deps")@patch("controllers.inner_api.app.dsl._get_active_account")- def test_import_pending_returns_202(self, mock_get_account, api_instance, app: Flask):- mock_get_account.return_value = MagicMock()+ def test_import_pending_returns_202(self, mock_get_account, api_instance, app: Flask, sqlite_session: Session):+ mock_get_account.return_value = _persist_account(sqlite_session)+ self._transaction_events.clear()self._mock_dsl.import_app.return_value = self._make_import_result(ImportStatus.PENDING)unwrapped = inspect.unwrap(api_instance.post)@@ -199,10 +219,9 @@ class TestEnterpriseAppDSLImport:@pytest.mark.usefixtures("_mock_import_deps")@patch("controllers.inner_api.app.dsl._get_active_account")- def test_import_failed_returns_400(self, mock_get_account, api_instance, app: Flask):- mock_account = MagicMock()- mock_account.set_tenant_id_with_session.side_effect = lambda _tenant_id, *, session: session.execute(select(1))- mock_get_account.return_value = mock_account+ def test_import_failed_returns_400(self, mock_get_account, api_instance, app: Flask, sqlite_session: Session):+ mock_get_account.return_value = _persist_account(sqlite_session)+ self._transaction_events.clear()self._mock_dsl.import_app.return_value = self._make_import_result(ImportStatus.FAILED)unwrapped = inspect.unwrap(api_instance.post)diff --git a/api/tests/unit_tests/controllers/inner_api/workspace/test_workspace.py b/api/tests/unit_tests/controllers/inner_api/workspace/test_workspace.pyindex 35b18ae7d20..27f0a90bd14 100644--- a/api/tests/unit_tests/controllers/inner_api/workspace/test_workspace.py+++ b/api/tests/unit_tests/controllers/inner_api/workspace/test_workspace.py@@ -8,11 +8,12 @@ handler tests use inspect.unwrap() to bypass them and focus on business logic.import inspectfrom datetime import datetime-from unittest.mock import ANY, MagicMock, patch+from unittest.mock import patchimport pytestfrom flask import Flaskfrom pydantic import ValidationError+from sqlalchemy.orm import Session, scoped_session, sessionmakerfrom controllers.inner_api.workspace.workspace import (EnterpriseWorkspace,@@ -20,9 +21,18 @@ from controllers.inner_api.workspace.workspace import (WorkspaceCreatePayload,WorkspaceOwnerlessPayload,)+from models import Account, Tenantfrom models.account import TenantStatus+def database_session(sqlite_session_factory: sessionmaker[Session]):+ session_proxy = scoped_session(sqlite_session_factory)+ with patch("controllers.inner_api.workspace.workspace.db.session", session_proxy):+ yield session_proxy+ session_proxy.remove()++class TestWorkspaceCreatePayload:"""Test WorkspaceCreatePayload Pydantic model validation"""@@ -85,23 +95,21 @@ class TestEnterpriseWorkspace:assert callable(api_instance.post)@patch("controllers.inner_api.workspace.workspace.TenantService")- @patch("controllers.inner_api.workspace.workspace.db")- def test_post_creates_workspace_with_owner(self, mock_db, mock_tenant_svc, api_instance, app: Flask):+ def test_post_creates_workspace_with_owner(+ self, mock_tenant_svc, api_instance, app: Flask, sqlite_session: Session, database_session+ ):"""Test that post() creates a workspace and assigns the owner account"""# Arrange- mock_account = MagicMock()- mock_account.email = "[email protected]"- mock_db.session.scalar.return_value = mock_account+ account = Account(name="Owner", email="[email protected]")+ sqlite_session.add(account)+ sqlite_session.commit()now = datetime(2025, 1, 1, 12, 0, 0)- mock_tenant = MagicMock()- mock_tenant.id = "tenant-id"- mock_tenant.name = "My Workspace"- mock_tenant.plan = "sandbox"- mock_tenant.status = TenantStatus.NORMAL- mock_tenant.created_at = now- mock_tenant.updated_at = now- mock_tenant_svc.create_owner_tenant.return_value = mock_tenant+ tenant = Tenant(name="My Workspace", plan="sandbox", status=TenantStatus.NORMAL)+ tenant.id = "tenant-id"+ tenant.created_at = now+ tenant.updated_at = now+ mock_tenant_svc.create_owner_tenant.return_value = tenant# Act — unwrap to bypass auth/setup decorators (tested in test_auth_wraps.py)unwrapped_post = inspect.unwrap(api_instance.post)@@ -114,19 +122,18 @@ class TestEnterpriseWorkspace:assert result["message"] == "enterprise workspace created."assert result["tenant"]["id"] == "tenant-id"assert result["tenant"]["name"] == "My Workspace"- mock_tenant_svc.create_owner_tenant.assert_called_once_with(- mock_account,- name="My Workspace",- is_from_dashboard=True,- session=ANY,- )+ mock_tenant_svc.create_owner_tenant.assert_called_once()+ call_args = mock_tenant_svc.create_owner_tenant.call_args+ assert call_args.args[0].id == account.id+ assert call_args.kwargs == {+ "name": "My Workspace",+ "is_from_dashboard": True,+ "session": database_session(),+ }- @patch("controllers.inner_api.workspace.workspace.db")- def test_post_returns_404_when_owner_not_found(self, mock_db, api_instance, app: Flask):+ @pytest.mark.usefixtures("database_session")+ def test_post_returns_404_when_owner_not_found(self, api_instance, app: Flask):"""Test that post() returns 404 when the owner account does not exist"""- # Arrange- mock_db.session.scalar.return_value = None-# Actunwrapped_post = inspect.unwrap(api_instance.post)with app.test_request_context():@@ -156,20 +163,22 @@ class TestEnterpriseWorkspaceNoOwnerEmail:@patch("controllers.inner_api.workspace.workspace.tenant_was_created")@patch("controllers.inner_api.workspace.workspace.TenantService")- def test_post_creates_ownerless_workspace(self, mock_tenant_svc, mock_event, api_instance, app: Flask):+ def test_post_creates_ownerless_workspace(+ self, mock_tenant_svc, mock_event, api_instance, app: Flask, database_session+ ):"""Test that post() creates a workspace without an owner and returns expected fields"""# Arrangenow = datetime(2025, 1, 1, 12, 0, 0)- mock_tenant = MagicMock()- mock_tenant.id = "tenant-id"- mock_tenant.name = "My Workspace"- mock_tenant.encrypt_public_key = "pub-key"- mock_tenant.plan = "sandbox"- mock_tenant.status = TenantStatus.NORMAL- mock_tenant.custom_config = None- mock_tenant.created_at = now- mock_tenant.updated_at = now- mock_tenant_svc.create_tenant.return_value = mock_tenant+ tenant = Tenant(+ name="My Workspace",+ encrypt_public_key="pub-key",+ plan="sandbox",+ status=TenantStatus.NORMAL,+ )+ tenant.id = "tenant-id"+ tenant.created_at = now+ tenant.updated_at = now+ mock_tenant_svc.create_tenant.return_value = tenant# Act — unwrap to bypass auth/setup decorators (tested in test_auth_wraps.py)unwrapped_post = inspect.unwrap(api_instance.post)@@ -183,5 +192,7 @@ class TestEnterpriseWorkspaceNoOwnerEmail:assert result["tenant"]["id"] == "tenant-id"assert result["tenant"]["encrypt_public_key"] == "pub-key"assert result["tenant"]["custom_config"] == {}- mock_tenant_svc.create_tenant.assert_called_once_with("My Workspace", is_from_dashboard=True, session=ANY)- mock_event.send.assert_called_once_with(mock_tenant)+ mock_tenant_svc.create_tenant.assert_called_once_with(+ "My Workspace", is_from_dashboard=True, session=database_session()+ )+ mock_event.send.assert_called_once_with(tenant)diff --git a/api/tests/unit_tests/controllers/service_api/dataset/rag_pipeline/test_rag_pipeline_workflow.py b/api/tests/unit_tests/controllers/service_api/dataset/rag_pipeline/test_rag_pipeline_workflow.pyindex d7c524e6532..df1c9ff00d2 100644--- a/api/tests/unit_tests/controllers/service_api/dataset/rag_pipeline/test_rag_pipeline_workflow.py+++ b/api/tests/unit_tests/controllers/service_api/dataset/rag_pipeline/test_rag_pipeline_workflow.py@@ -13,18 +13,19 @@ Strategy:- Endpoint methods on these resources have no billing decorators on the methoditself. ``method_decorators = [validate_dataset_token]`` is only invoked byFlask-RESTx dispatch, not by direct calls, so we call methods directly.-- Only ``KnowledgebasePipelineFileUploadApi.post`` touches ``db`` inline- (via ``FileService(db.engine)``); the other endpoints delegate to services.+- Dataset ownership checks run against the shared SQLite fixture; pipeline and+ upload responses use real mapped instances while external services stay mocked."""import ioimport uuidfrom datetime import UTC, datetime+from types import SimpleNamespacefrom unittest.mock import Mock, patchimport pytestfrom flask import Flask-from sqlalchemy.orm import Session+from sqlalchemy.orm import Session, scoped_session, sessionmakerfrom werkzeug.datastructures import FileStoragefrom werkzeug.exceptions import Forbidden, NotFound@@ -37,6 +38,7 @@ from controllers.common.errors import (FileTooLargeError as FileTooLargeHTTPError,)from controllers.service_api.dataset.error import PipelineRunError+from controllers.service_api.dataset.rag_pipeline import rag_pipeline_workflow as workflow_modulefrom controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow import (DatasourceNodeRunApi,DatasourceNodeRunPayload,@@ -45,8 +47,11 @@ from controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow import (PipelineRunApi,)from core.app.entities.app_invoke_entities import InvokeFrom+from extensions.storage.storage_type import StorageTypefrom models.account import Account-from models.dataset import Dataset+from models.dataset import Dataset, Pipeline+from models.enums import CreatorUserRole+from models.model import UploadFilefrom services.errors.file import FileTooLargeError as FileTooLargeServiceErrorfrom services.errors.file import UnsupportedFileTypeErrorfrom services.rag_pipeline.entity.pipeline_service_api_entities import (@@ -70,6 +75,21 @@ def _persist_dataset(session: Session, *, tenant_id: str, dataset_id: str) -> Dareturn dataset+def _persist_pipeline(session: Session, *, tenant_id: str) -> Pipeline:+ pipeline = Pipeline(tenant_id=tenant_id, name="Knowledge pipeline")+ session.add(pipeline)+ session.commit()+ return pipeline++[email protected](autouse=True)+def _bind_database(sqlite_session_factory: sessionmaker[Session], monkeypatch: pytest.MonkeyPatch):+ session_proxy = scoped_session(sqlite_session_factory)+ monkeypatch.setattr(workflow_module.db, "session", session_proxy)+ yield+ session_proxy.remove()++class TestDatasourceNodeRunPayload:"""Test suite for DatasourceNodeRunPayload Pydantic model."""@@ -398,15 +418,13 @@ class TestDatasourcePluginsApiGet:an inline dataset query, so no ``db`` patching is needed."""- @patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.db")@patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.RagPipelineService")- def test_get_plugins_success(self, mock_svc_cls, mock_db, app: Flask):+ def test_get_plugins_success(self, mock_svc_cls, app: Flask, sqlite_session: Session):"""Test successful retrieval of datasource plugins."""tenant_id = str(uuid.uuid4())dataset_id = str(uuid.uuid4())- mock_dataset = Mock()- mock_db.session.scalar.return_value = mock_dataset+ _persist_dataset(sqlite_session, tenant_id=tenant_id, dataset_id=dataset_id)datasource_plugins = [{@@ -433,14 +451,13 @@ class TestDatasourcePluginsApiGet:tenant_id=tenant_id, dataset_id=dataset_id, is_published=True)- @patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.db")@patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.RagPipelineService")- def test_get_plugins_parses_false_is_published_query(self, mock_svc_cls, mock_db, app: Flask):+ def test_get_plugins_parses_false_is_published_query(self, mock_svc_cls, app: Flask, sqlite_session: Session):"""Test false query string is parsed as boolean False."""tenant_id = str(uuid.uuid4())dataset_id = str(uuid.uuid4())- mock_db.session.scalar.return_value = Mock()+ _persist_dataset(sqlite_session, tenant_id=tenant_id, dataset_id=dataset_id)mock_svc_instance = Mock()mock_svc_instance.get_datasource_plugins.return_value = []mock_svc_cls.return_value = mock_svc_instance@@ -455,28 +472,30 @@ class TestDatasourcePluginsApiGet:tenant_id=tenant_id, dataset_id=dataset_id, is_published=False)- @patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.db")- def test_get_plugins_not_found(self, mock_db, app: Flask):+ def test_get_plugins_not_found(self, app: Flask, sqlite_session: Session):"""Test NotFound when dataset check fails."""- mock_db.session.scalar.return_value = None+ tenant_id = str(uuid.uuid4())+ dataset_id = str(uuid.uuid4())+ _persist_dataset(sqlite_session, tenant_id="other-tenant", dataset_id=dataset_id)with app.test_request_context("/datasets/test/pipeline/datasource-plugins"):api = DatasourcePluginsApi()with pytest.raises(NotFound):- api.get(tenant_id=str(uuid.uuid4()), dataset_id=str(uuid.uuid4()))+ api.get(tenant_id=tenant_id, dataset_id=dataset_id)- @patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.db")@patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.RagPipelineService")- def test_get_plugins_empty_list(self, mock_svc_cls, mock_db, app: Flask):+ def test_get_plugins_empty_list(self, mock_svc_cls, app: Flask, sqlite_session: Session):"""Test empty plugin list."""- mock_db.session.scalar.return_value = Mock()+ tenant_id = str(uuid.uuid4())+ dataset_id = str(uuid.uuid4())+ _persist_dataset(sqlite_session, tenant_id=tenant_id, dataset_id=dataset_id)mock_svc_instance = Mock()mock_svc_instance.get_datasource_plugins.return_value = []mock_svc_cls.return_value = mock_svc_instancewith app.test_request_context("/datasets/test/pipeline/datasource-plugins"):api = DatasourcePluginsApi()- response, status = api.get(tenant_id=str(uuid.uuid4()), dataset_id=str(uuid.uuid4()))+ response, status = api.get(tenant_id=tenant_id, dataset_id=dataset_id)assert status == 200assert response == []@@ -497,15 +516,23 @@ class TestDatasourceNodeRunApiPost:new_callable=lambda: Account(name="Test Account", email="[email protected]"),)@patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.RagPipelineService")- @patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.db")@patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.service_api_ns")- def test_post_success(self, mock_ns, mock_db, mock_svc_cls, mock_current_user, mock_gen, mock_helper, app: Flask):+ def test_post_success(+ self,+ mock_ns,+ mock_svc_cls,+ current_account,+ mock_gen,+ mock_helper,+ app: Flask,+ sqlite_session: Session,+ ):"""Test successful datasource node run."""tenant_id = str(uuid.uuid4())dataset_id = str(uuid.uuid4())node_id = "node_abc"- mock_db.session.scalar.return_value = Mock()+ _persist_dataset(sqlite_session, tenant_id=tenant_id, dataset_id=dataset_id)mock_ns.payload = {"inputs": {"url": "https://example.com"},@@ -513,10 +540,9 @@ class TestDatasourceNodeRunApiPost:"is_published": True,}- mock_pipeline = Mock()- mock_pipeline.id = str(uuid.uuid4())+ pipeline = _persist_pipeline(sqlite_session, tenant_id=tenant_id)mock_svc_instance = Mock()- mock_svc_instance.get_pipeline.return_value = mock_pipeline+ mock_svc_instance.get_pipeline.return_value = pipelinemock_svc_instance.run_datasource_workflow_node.return_value = iter(["event1"])mock_svc_cls.return_value = mock_svc_instance@@ -532,10 +558,8 @@ class TestDatasourceNodeRunApiPost:mock_svc_instance.get_pipeline.assert_called_once_with(tenant_id=tenant_id, dataset_id=dataset_id)mock_svc_instance.run_datasource_workflow_node.assert_called_once()- @patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.db")- def test_post_not_found(self, mock_db, app: Flask):+ def test_post_not_found(self, app: Flask, sqlite_session: Session):"""Test NotFound when dataset check fails."""- mock_db.session.scalar.return_value = Nonewith app.test_request_context("/datasets/test/pipeline/datasource/nodes/n1/run", method="POST"):api = DatasourceNodeRunApi()@@ -546,11 +570,12 @@ class TestDatasourceNodeRunApiPost:"controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.current_user",new="not_account",)- @patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.db")@patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.service_api_ns")- def test_post_fails_when_current_user_not_account(self, mock_ns, mock_db, app: Flask):+ def test_post_fails_when_current_user_not_account(self, mock_ns, app: Flask, sqlite_session: Session):"""Test AssertionError when current_user is not an Account instance."""- mock_db.session.scalar.return_value = Mock()+ tenant_id = str(uuid.uuid4())+ dataset_id = str(uuid.uuid4())+ _persist_dataset(sqlite_session, tenant_id=tenant_id, dataset_id=dataset_id)mock_ns.payload = {"inputs": {},"datasource_type": "local_file",@@ -560,7 +585,7 @@ class TestDatasourceNodeRunApiPost:with app.test_request_context("/datasets/test/pipeline/datasource/nodes/n1/run", method="POST"):api = DatasourceNodeRunApi()with pytest.raises(AssertionError):- api.post(tenant_id=str(uuid.uuid4()), dataset_id=str(uuid.uuid4()), node_id="n1")+ api.post(tenant_id=tenant_id, dataset_id=dataset_id, node_id="n1")class TestPipelineRunApiPost:@@ -592,9 +617,9 @@ class TestPipelineRunApiPost:"response_mode": "streaming",}- mock_pipeline = Mock()+ pipeline = _persist_pipeline(sqlite_session, tenant_id=tenant_id)mock_svc_instance = Mock()- mock_svc_instance.get_pipeline.return_value = mock_pipeline+ mock_svc_instance.get_pipeline.return_value = pipelinemock_svc_cls.return_value = mock_svc_instancemock_gen_svc.generate.return_value = {"result": "ok"}@@ -651,23 +676,29 @@ class TestFileUploadApiPost:"""Tests for KnowledgebasePipelineFileUploadApi.post()."""@patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.FileService")- @patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.current_user")- @patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.db")- def test_upload_success(self, mock_db, mock_current_user, mock_file_svc_cls, app: Flask):+ @patch(+ "controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.current_user",+ new_callable=lambda: Account(name="Upload User", email="[email protected]"),+ )+ def test_upload_success(self, current_account, mock_file_svc_cls, app: Flask, sqlite_engine):"""Test successful file upload."""- mock_current_user.__bool__ = Mock(return_value=True)-- mock_upload = Mock()- mock_upload.id = str(uuid.uuid4())- mock_upload.name = "doc.pdf"- mock_upload.size = 1024- mock_upload.extension = "pdf"- mock_upload.mime_type = "application/pdf"- mock_upload.created_by = str(uuid.uuid4())- mock_upload.created_at = datetime(2024, 1, 1, tzinfo=UTC)+ current_account.id = str(uuid.uuid4())+ upload = UploadFile(+ tenant_id=str(uuid.uuid4()),+ storage_type=StorageType.LOCAL,+ key="pipeline/doc.pdf",+ name="doc.pdf",+ size=1024,+ extension="pdf",+ mime_type="application/pdf",+ created_by_role=CreatorUserRole.ACCOUNT,+ created_by=current_account.id,+ created_at=datetime(2024, 1, 1, tzinfo=UTC),+ used=False,+ )mock_file_svc_instance = Mock()- mock_file_svc_instance.upload_file.return_value = mock_upload+ mock_file_svc_instance.upload_file.return_value = uploadmock_file_svc_cls.return_value = mock_file_svc_instancefile_data = FileStorage(@@ -676,14 +707,16 @@ class TestFileUploadApiPost:content_type="application/pdf",)- with app.test_request_context(- "/datasets/pipeline/file-upload",- method="POST",- content_type="multipart/form-data",- data={"file": file_data},+ with (+ patch.object(workflow_module, "db", SimpleNamespace(engine=sqlite_engine)),+ app.test_request_context(+ "/datasets/pipeline/file-upload",+ method="POST",+ content_type="multipart/form-data",+ data={"file": file_data},+ ),):- api = KnowledgebasePipelineFileUploadApi()- response, status = api.post(tenant_id=str(uuid.uuid4()))+ response, status = KnowledgebasePipelineFileUploadApi().post(tenant_id=str(uuid.uuid4()))assert status == 201assert response["name"] == "doc.pdf"@@ -695,12 +728,13 @@ class TestFileUploadApiPost:return_value=15,)@patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.FileService")- @patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.current_user")- @patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.db")+ @patch(+ "controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.current_user",+ new_callable=lambda: Account(name="Upload User", email="[email protected]"),+ )def test_upload_file_too_large_returns_http_413(- self, mock_db, mock_current_user, mock_file_svc_cls, mock_get_limit, app: Flask+ self, current_account, mock_file_svc_cls, mock_get_limit, app: Flask, sqlite_engine):- mock_current_user.__bool__ = Mock(return_value=True)mock_file_svc_cls.return_value.upload_file.side_effect = FileTooLargeServiceError()file_data = FileStorage(stream=io.BytesIO(b"oversized content"),@@ -708,11 +742,14 @@ class TestFileUploadApiPost:content_type="application/pdf",)- with app.test_request_context(- "/datasets/pipeline/file-upload",- method="POST",- content_type="multipart/form-data",- data={"file": file_data},+ with (+ patch.object(workflow_module, "db", SimpleNamespace(engine=sqlite_engine)),+ app.test_request_context(+ "/datasets/pipeline/file-upload",+ method="POST",+ content_type="multipart/form-data",+ data={"file": file_data},+ ),):with pytest.raises(FileTooLargeHTTPError) as exc_info:KnowledgebasePipelineFileUploadApi().post(tenant_id="tenant-1")diff --git a/api/tests/unit_tests/extensions/test_ext_login.py b/api/tests/unit_tests/extensions/test_ext_login.pyindex bcf182c180e..d58e7f52e56 100644--- a/api/tests/unit_tests/extensions/test_ext_login.py+++ b/api/tests/unit_tests/extensions/test_ext_login.py@@ -4,6 +4,7 @@ from unittest import mockimport pytestfrom flask import Flask, Response, request+from sqlalchemy.orm import Sessionfrom constants import COOKIE_NAME_ACCESS_TOKENfrom core.logging.context import clear_request_context, get_identity_context@@ -87,19 +88,22 @@ def test_on_user_logged_in_logs_unsupported_user_type(caplog: pytest.LogCaptureFassert "Failed to set logging identity context" in caplog.text-def test_admin_api_key_header_takes_precedence_over_console_cookie(monkeypatch: pytest.MonkeyPatch) -> None:+def test_admin_api_key_header_takes_precedence_over_console_cookie(+ monkeypatch: pytest.MonkeyPatch, sqlite_session: Session+) -> None:app = Flask(__name__)- session = mock.Mock(spec=ext_login.Session)tenant = ext_login.Tenant(name="Test Tenant")+ tenant.id = "workspace-id"+ account = ext_login.Account(name="Test Account", email="[email protected]")+ sqlite_session.add_all([tenant, account])+ sqlite_session.flush()tenant_account_join = ext_login.TenantAccountJoin(- tenant_id="tenant-id",- account_id="account-id",- role=TenantAccountRole.NORMAL,+ tenant_id=tenant.id,+ account_id=account.id,+ role=TenantAccountRole.OWNER,)- account = ext_login.Account(name="Test Account", email="[email protected]")- session.execute.return_value.one_or_none.return_value = (tenant, tenant_account_join)- session.scalar.side_effect = [account, tenant_account_join]- session.scalars.return_value.one.return_value = tenant+ sqlite_session.add(tenant_account_join)+ sqlite_session.commit()monkeypatch.setattr(ext_login.dify_config, "ADMIN_API_KEY_ENABLE", True)monkeypatch.setattr(ext_login.dify_config, "ADMIN_API_KEY", "admin-key")monkeypatch.setattr(ext_login.dify_config, "CONSOLE_WEB_URL", "http://console.example.com")@@ -114,7 +118,7 @@ def test_admin_api_key_header_takes_precedence_over_console_cookie(monkeypatch:"X-WORKSPACE-ID": "workspace-id",},):- result = ext_login._load_user_from_request(request, session)+ result = ext_login._load_user_from_request(request, sqlite_session)assert result is accountassert account.current_tenant is tenant