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: use sqlite3 session in test_plugin_wraps (#38681)
Asuka Minato4a2e92f43fc4
diff --git a/api/tests/unit_tests/controllers/inner_api/plugin/test_plugin_wraps.py b/api/tests/unit_tests/controllers/inner_api/plugin/test_plugin_wraps.pyindex c958034126d..5faf7828f57 100644--- a/api/tests/unit_tests/controllers/inner_api/plugin/test_plugin_wraps.py+++ b/api/tests/unit_tests/controllers/inner_api/plugin/test_plugin_wraps.py@@ -2,19 +2,75 @@Unit tests for inner_api plugin decorators"""+from collections.abc import Iterator+from types import SimpleNamespacefrom typing import Anyfrom unittest.mock import MagicMock, patchimport pytestfrom flask import Flaskfrom pydantic import ValidationError+from sqlalchemy import Engine, event, select+from sqlalchemy.orm import Session, scoped_session, sessionmaker+from controllers.inner_api.plugin import wraps as wraps_modulefrom controllers.inner_api.plugin.wraps import (TenantUserPayload,get_user,get_user_tenant,plugin_data,)+from models.account import Tenant+from models.base import TypeBase+from models.enums import EndUserType+from models.model import DefaultEndUserSessionID, EndUser+++def sqlite_plugin_engine(+ sqlite_engine: Engine,+ monkeypatch: pytest.MonkeyPatch,+) -> Iterator[Engine]:+ tables = [TypeBase.metadata.tables[model.__tablename__] for model in (Tenant, EndUser)]+ TypeBase.metadata.create_all(sqlite_engine, tables=tables)+ session_registry = scoped_session(sessionmaker(bind=sqlite_engine, expire_on_commit=False))+ monkeypatch.setattr(+ wraps_module,+ "db",+ SimpleNamespace(engine=sqlite_engine, session=session_registry),+ )+ try:+ yield sqlite_engine+ finally:+ session_registry.remove()+++def _persist_tenant(sqlite_engine: Engine, *, tenant_id: str = "tenant123") -> Tenant:+ tenant = Tenant(name=f"Tenant {tenant_id}")+ tenant.id = tenant_id+ with Session(sqlite_engine) as session, session.begin():+ session.add(tenant)+ return tenant+++def _persist_end_user(+ sqlite_engine: Engine,+ *,+ tenant_id: str = "tenant123",+ user_id: str,+ session_id: str,+ is_anonymous: bool = False,+) -> EndUser:+ user = EndUser(+ id=user_id,+ tenant_id=tenant_id,+ type=EndUserType.SERVICE_API,+ is_anonymous=is_anonymous,+ session_id=session_id,+ )+ with Session(sqlite_engine) as session, session.begin():+ session.add(user)+ return userclass TestTenantUserPayload:@@ -41,185 +97,143 @@ class TestTenantUserPayload:class TestGetUser:"""Test get_user function"""- @patch("controllers.inner_api.plugin.wraps.select")- @patch("controllers.inner_api.plugin.wraps.EndUser")- @patch("controllers.inner_api.plugin.wraps.sessionmaker")- @patch("controllers.inner_api.plugin.wraps.db")- def test_should_return_existing_user_by_id(- self, mock_db, mock_sessionmaker, mock_enduser_class, mock_select, app: Flask- ):+ def test_should_return_existing_user_by_id(self, sqlite_plugin_engine: Engine, app: Flask):"""Test returning existing user when found by ID"""- # Arrange- mock_user = MagicMock()- mock_user.id = "user123"- mock_session = MagicMock()- mock_sessionmaker.return_value.begin.return_value.__enter__.return_value = mock_session- mock_session.scalar.return_value = mock_user- mock_query = MagicMock()- mock_select.return_value.where.return_value.limit.return_value = mock_query+ _persist_end_user(+ sqlite_plugin_engine,+ user_id="user123",+ session_id="existing-session",+ )- # Actwith app.app_context():result = get_user("tenant123", "user123")- # Assert- assert result == mock_user- mock_session.scalar.assert_called_once()+ assert result.id == "user123"+ assert result.tenant_id == "tenant123"- @patch("controllers.inner_api.plugin.wraps.select")- @patch("controllers.inner_api.plugin.wraps.EndUser")- @patch("controllers.inner_api.plugin.wraps.sessionmaker")- @patch("controllers.inner_api.plugin.wraps.db")def test_should_not_resolve_non_anonymous_users_across_tenants(self,- mock_db,- mock_sessionmaker,- mock_enduser_class,- mock_select,+ sqlite_plugin_engine: Engine,app: Flask,):"""Test that explicit user IDs remain scoped to the current tenant."""- # Arrange- mock_session = MagicMock()- mock_sessionmaker.return_value.begin.return_value.__enter__.return_value = mock_session- mock_session.scalar.return_value = None- mock_new_user = MagicMock()- mock_new_user.tenant_id = "tenant-current"- mock_enduser_class.return_value = mock_new_user+ _persist_end_user(+ sqlite_plugin_engine,+ tenant_id="tenant-foreign",+ user_id="foreign-user-id",+ session_id="foreign-session",+ )- # Actwith app.app_context():result = get_user("tenant-current", "foreign-user-id")- # Assert- assert result == mock_new_user- mock_session.get.assert_not_called()- # Non-anonymous miss now tries id, then session_id fallback (see- # #36736); both miss in this tenant → fall through to create.- assert mock_session.scalar.call_count == 2- mock_session.add.assert_called_once_with(mock_new_user)-- @patch("controllers.inner_api.plugin.wraps.select")- @patch("controllers.inner_api.plugin.wraps.EndUser")- @patch("controllers.inner_api.plugin.wraps.sessionmaker")- @patch("controllers.inner_api.plugin.wraps.db")+ assert result.id != "foreign-user-id"+ assert result.tenant_id == "tenant-current"+ assert result.session_id == "foreign-user-id"+ with Session(sqlite_plugin_engine) as session:+ current_tenant_users = session.scalars(select(EndUser).where(EndUser.tenant_id == "tenant-current")).all()+ assert [user.id for user in current_tenant_users] == [result.id]+def test_should_return_existing_user_by_session_id_fallback_for_non_anonymous(- self, mock_db, mock_sessionmaker, mock_enduser_class, mock_select, app: Flask+ self,+ sqlite_plugin_engine: Engine,+ app: Flask,):"""Non-anonymous user_id misses on EndUser.id but hits onEndUser.session_id — this is the plugin-daemon Reverse Invocationcase where the daemon sends a stable session-derived UUID thatwas written into session_id on the first call. See #36736."""- # Arrange- mock_user = MagicMock()- mock_session = MagicMock()- mock_sessionmaker.return_value.begin.return_value.__enter__.return_value = mock_session- # First scalar (id lookup) returns None, second (session_id fallback) hits.- mock_session.scalar.side_effect = [None, mock_user]+ _persist_end_user(+ sqlite_plugin_engine,+ user_id="persisted-user-id",+ session_id="daemon-session-uuid",+ )- # Actwith app.app_context():result = get_user("tenant123", "daemon-session-uuid")- # Assert- assert result == mock_user- assert mock_session.scalar.call_count == 2- mock_session.add.assert_not_called()-- @patch("controllers.inner_api.plugin.wraps.select")- @patch("controllers.inner_api.plugin.wraps.EndUser")- @patch("controllers.inner_api.plugin.wraps.sessionmaker")- @patch("controllers.inner_api.plugin.wraps.db")+ assert result.id == "persisted-user-id"+ with Session(sqlite_plugin_engine) as session:+ users = session.scalars(select(EndUser)).all()+ assert [user.id for user in users] == ["persisted-user-id"]+def test_should_return_existing_anonymous_user_by_session_id(- self, mock_db, mock_sessionmaker, mock_enduser_class, mock_select, app: Flask+ self,+ sqlite_plugin_engine: Engine,+ app: Flask,):"""Test returning existing anonymous user by session_id"""- # Arrange- mock_user = MagicMock()- mock_user.session_id = "anonymous_session"- mock_session = MagicMock()- mock_sessionmaker.return_value.begin.return_value.__enter__.return_value = mock_session- mock_session.scalar.return_value = mock_user- mock_query = MagicMock()- mock_select.return_value.where.return_value.limit.return_value = mock_query+ _persist_end_user(+ sqlite_plugin_engine,+ user_id="anonymous-user-id",+ session_id="anonymous_session",+ is_anonymous=True,+ )- # Actwith app.app_context():result = get_user("tenant123", "anonymous_session")- # Assert- assert result == mock_user+ assert result.id == "anonymous-user-id"- @patch("controllers.inner_api.plugin.wraps.select")- @patch("controllers.inner_api.plugin.wraps.EndUser")- @patch("controllers.inner_api.plugin.wraps.sessionmaker")- @patch("controllers.inner_api.plugin.wraps.db")def test_should_create_new_user_when_not_found(- self, mock_db, mock_sessionmaker, mock_enduser_class, mock_select, app: Flask+ self,+ sqlite_plugin_engine: Engine,+ app: Flask,):"""Test creating new user when not found in database"""- # Arrange- mock_session = MagicMock()- mock_sessionmaker.return_value.begin.return_value.__enter__.return_value = mock_session- mock_session.scalar.return_value = None- mock_new_user = MagicMock()- mock_enduser_class.return_value = mock_new_user- mock_query = MagicMock()- mock_select.return_value.where.return_value.limit.return_value = mock_query-- # Actwith app.app_context():result = get_user("tenant123", "user123")- # Assert- assert result == mock_new_user- mock_session.add.assert_called_once()- mock_session.refresh.assert_called_once()-- @patch("controllers.inner_api.plugin.wraps.select")- @patch("controllers.inner_api.plugin.wraps.EndUser")- @patch("controllers.inner_api.plugin.wraps.sessionmaker")- @patch("controllers.inner_api.plugin.wraps.db")+ assert result.tenant_id == "tenant123"+ assert result.session_id == "user123"+ with Session(sqlite_plugin_engine) as session:+ persisted_user = session.get(EndUser, result.id)+ assert persisted_user is not None+ assert persisted_user.session_id == "user123"+def test_should_use_default_session_id_when_user_id_none(- self, mock_db, mock_sessionmaker, mock_enduser_class, mock_select, app: Flask+ self,+ sqlite_plugin_engine: Engine,+ app: Flask,):"""Test using default session ID when user_id is None"""- # Arrange- mock_user = MagicMock()- mock_session = MagicMock()- mock_sessionmaker.return_value.begin.return_value.__enter__.return_value = mock_session- # When user_id is None, is_anonymous=True, so session.scalar() is used- mock_session.scalar.return_value = mock_user+ _persist_end_user(+ sqlite_plugin_engine,+ user_id="default-user-id",+ session_id=DefaultEndUserSessionID.DEFAULT_SESSION_ID,+ is_anonymous=True,+ )- # Actwith app.app_context():result = get_user("tenant123", None)- # Assert- assert result == mock_user+ assert result.id == "default-user-id"+ assert result.session_id == DefaultEndUserSessionID.DEFAULT_SESSION_ID- @patch("controllers.inner_api.plugin.wraps.EndUser")- @patch("controllers.inner_api.plugin.wraps.sessionmaker")- @patch("controllers.inner_api.plugin.wraps.db")- def test_should_raise_error_on_database_exception(self, mock_db, mock_sessionmaker, mock_enduser_class, app: Flask):+ def test_should_raise_error_on_database_exception(self, sqlite_plugin_engine: Engine, app: Flask):"""Test raising ValueError when database operation fails"""- # Arrange- mock_session = MagicMock()- mock_sessionmaker.return_value.begin.return_value.__enter__.return_value = mock_session- mock_session.scalar.side_effect = Exception("Database error")- # Act & Assert- with app.app_context():- with pytest.raises(ValueError, match="user not found"):+ def _raise_database_error(*_args, **_kwargs):+ raise RuntimeError("Database error")++ event.listen(sqlite_plugin_engine, "before_cursor_execute", _raise_database_error)+ try:+ with app.app_context(), pytest.raises(ValueError, match="user not found"):get_user("tenant123", "user123")+ finally:+ event.remove(sqlite_plugin_engine, "before_cursor_execute", _raise_database_error)class TestGetUserTenant:"""Test get_user_tenant decorator"""- @patch("controllers.inner_api.plugin.wraps.Tenant")- def test_should_inject_tenant_and_user_models(self, mock_tenant_class, app: Flask, monkeypatch: pytest.MonkeyPatch):+ def test_should_inject_tenant_and_user_models(+ self,+ sqlite_plugin_engine: Engine,+ app: Flask,+ monkeypatch: pytest.MonkeyPatch,+ ):"""Test that decorator injects tenant_model and user_model into kwargs"""# Arrange@@ -227,24 +241,20 @@ class TestGetUserTenant:def protected_view(tenant_model, user_model, **kwargs):return {"tenant": tenant_model, "user": user_model}- mock_tenant = MagicMock()- mock_tenant.id = "tenant123"- mock_user = MagicMock()- mock_user.id = "user456"+ _persist_tenant(sqlite_plugin_engine)+ _persist_end_user(+ sqlite_plugin_engine,+ user_id="user456",+ session_id="user-session",+ )- # Actwith app.test_request_context(json={"tenant_id": "tenant123", "user_id": "user456"}):monkeypatch.setattr(app, "login_manager", MagicMock(), raising=False)- with patch("controllers.inner_api.plugin.wraps.db.session.get") as mock_get:- with patch("controllers.inner_api.plugin.wraps.get_user") as mock_get_user:- with patch("controllers.inner_api.plugin.wraps.user_logged_in"):- mock_get.return_value = mock_tenant- mock_get_user.return_value = mock_user- result = protected_view()+ with patch("controllers.inner_api.plugin.wraps.user_logged_in"):+ result = protected_view()- # Assert- assert result["tenant"] == mock_tenant- assert result["user"] == mock_user+ assert result["tenant"].id == "tenant123"+ assert result["user"].id == "user456"def test_should_raise_error_when_tenant_id_missing(self, app: Flask):"""Test that Pydantic ValidationError is raised when tenant_id is missing from payload"""@@ -259,7 +269,7 @@ class TestGetUserTenant:with pytest.raises(ValidationError):protected_view()- def test_should_raise_error_when_tenant_not_found(self, app: Flask):+ def test_should_raise_error_when_tenant_not_found(self, sqlite_plugin_engine: Engine, app: Flask):"""Test that ValueError is raised when tenant is not found"""# Arrange@@ -267,16 +277,15 @@ class TestGetUserTenant:def protected_view(tenant_model, user_model, **kwargs):return "success"- # Act & Assertwith app.test_request_context(json={"tenant_id": "nonexistent", "user_id": "user456"}):- with patch("controllers.inner_api.plugin.wraps.db.session.get") as mock_get:- mock_get.return_value = None- with pytest.raises(ValueError, match="tenant not found"):- protected_view()+ with pytest.raises(ValueError, match="tenant not found"):+ protected_view()- @patch("controllers.inner_api.plugin.wraps.Tenant")def test_should_use_default_session_id_when_user_id_empty(- self, mock_tenant_class, app: Flask, monkeypatch: pytest.MonkeyPatch+ self,+ sqlite_plugin_engine: Engine,+ app: Flask,+ monkeypatch: pytest.MonkeyPatch,):"""Test that default session ID is used when user_id is empty string"""@@ -285,26 +294,22 @@ class TestGetUserTenant:def protected_view(tenant_model, user_model, **kwargs):return {"tenant": tenant_model, "user": user_model}- mock_tenant = MagicMock()- mock_tenant.id = "tenant123"- mock_user = MagicMock()+ _persist_tenant(sqlite_plugin_engine)+ _persist_end_user(+ sqlite_plugin_engine,+ user_id="default-user-id",+ session_id=DefaultEndUserSessionID.DEFAULT_SESSION_ID,+ is_anonymous=True,+ )- # Act - use empty string for user_id to trigger default logicwith app.test_request_context(json={"tenant_id": "tenant123", "user_id": ""}):monkeypatch.setattr(app, "login_manager", MagicMock(), raising=False)- with patch("controllers.inner_api.plugin.wraps.db.session.get") as mock_get:- with patch("controllers.inner_api.plugin.wraps.get_user") as mock_get_user:- with patch("controllers.inner_api.plugin.wraps.user_logged_in"):- mock_get.return_value = mock_tenant- mock_get_user.return_value = mock_user- result = protected_view()-- # Assert- assert result["tenant"] == mock_tenant- assert result["user"] == mock_user- from models.model import DefaultEndUserSessionID+ with patch("controllers.inner_api.plugin.wraps.user_logged_in"):+ result = protected_view()- mock_get_user.assert_called_once_with("tenant123", DefaultEndUserSessionID.DEFAULT_SESSION_ID)+ assert result["tenant"].id == "tenant123"+ assert result["user"].id == "default-user-id"+ assert result["user"].session_id == DefaultEndUserSessionID.DEFAULT_SESSION_IDclass PluginTestPayload: