Skip to content

armgit / dify

Public Imported from GitHub
0

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

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.py
index 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 patch
import pytest
+from sqlalchemy.orm import Session, scoped_session, sessionmaker
from werkzeug.exceptions import Forbidden
from controllers.console.app.error import AppNotFoundError
from controllers.console.app.wraps import agent_manage_required_for_agent_app
from 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, AppMode
TENANT_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.py
index 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 DeploymentEdition
from libs.login import AccountWithTenant
from machinery.context import RequestContext
from machinery.errors import ActiveWorkspaceRequiredError, AdmissionConfigurationError
-from models import Account
+from models import Account, DifySetup
from models.account import AccountStatus, TenantAccountRole
from models.dataset import Dataset, RateLimitLog
from 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_required
def 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()
# Assert
assert 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_required
def 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_required
def 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_required
def admin_view():
@@ -1042,17 +1050,15 @@ class TestSystemSetup:
# Act & Assert
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", "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_required
def admin_view():
@@ -1060,6 +1066,7 @@ class TestSystemSetup:
# Act & Assert
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", ""),
):
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.py
index 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 uuid4
import pytest
from flask import Flask
from pydantic import ValidationError
-from sqlalchemy import event, select
+from sqlalchemy import event
from sqlalchemy.engine import Engine
from 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, TenantAccountRole
from models.model import AppMode, IconType
from services.app_dsl_service import Import, ImportStatus
from 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 = account
self._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 = result
assert status_code == 200
assert 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 account
assert 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.py
index 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 inspect
from datetime import datetime
-from unittest.mock import ANY, MagicMock, patch
+from unittest.mock import patch
import pytest
from flask import Flask
from pydantic import ValidationError
+from sqlalchemy.orm import Session, scoped_session, sessionmaker
from controllers.inner_api.workspace.workspace import (
EnterpriseWorkspace,
@@ -20,9 +21,18 @@ from controllers.inner_api.workspace.workspace import (
WorkspaceCreatePayload,
WorkspaceOwnerlessPayload,
)
+from models import Account, Tenant
from 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
-
# Act
unwrapped_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"""
# Arrange
now = 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.py
index 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 method
itself. ``method_decorators = [validate_dataset_token]`` is only invoked by
Flask-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 io
import uuid
from datetime import UTC, datetime
+from types import SimpleNamespace
from unittest.mock import Mock, patch
import pytest
from flask import Flask
-from sqlalchemy.orm import Session
+from sqlalchemy.orm import Session, scoped_session, sessionmaker
from werkzeug.datastructures import FileStorage
from 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_module
from 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 StorageType
from models.account import Account
-from models.dataset import Dataset
+from models.dataset import Dataset, Pipeline
+from models.enums import CreatorUserRole
+from models.model import UploadFile
from services.errors.file import FileTooLargeError as FileTooLargeServiceError
from services.errors.file import UnsupportedFileTypeError
from services.rag_pipeline.entity.pipeline_service_api_entities import (
@@ -70,6 +75,21 @@ def _persist_dataset(session: Session, *, tenant_id: str, dataset_id: str) -> Da
return 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_instance
with 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 == 200
assert 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 = pipeline
mock_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 = None
with 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 = pipeline
mock_svc_cls.return_value = mock_svc_instance
mock_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 = upload
mock_file_svc_cls.return_value = mock_file_svc_instance
file_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 == 201
assert 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.py
index 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 mock
import pytest
from flask import Flask, Response, request
+from sqlalchemy.orm import Session
from constants import COOKIE_NAME_ACCESS_TOKEN
from 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.LogCaptureF
assert "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 account
assert account.current_tenant is tenant