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_message_service (#38698)
Asuka Minatob81737cfb334
diff --git a/api/tests/unit_tests/services/test_message_service.py b/api/tests/unit_tests/services/test_message_service.pyindex dfdaf7b40e2..afc49c8865c 100644--- a/api/tests/unit_tests/services/test_message_service.py+++ b/api/tests/unit_tests/services/test_message_service.py@@ -1,13 +1,35 @@import json+from collections.abc import Iteratorfrom datetime import datetime-from unittest.mock import MagicMock, patch+from decimal import Decimal+from unittest.mock import MagicMockimport pytest+from sqlalchemy.engine import Engine+from sqlalchemy.orm import Session, scoped_session+import models.model as model_module+import services.message_service as service_module+from core.app.entities.app_invoke_entities import InvokeFromfrom graphon.model_runtime.entities.model_entities import ModelType-from libs.infinite_scroll_pagination import InfiniteScrollPagination-from models.enums import FeedbackFromSource, FeedbackRating-from models.model import App, AppMode, EndUser, Message+from models.account import Account, AccountStatus+from models.enums import (+ ConversationFromSource,+ EndUserType,+ FeedbackFromSource,+ FeedbackRating,+)+from models.model import (+ App,+ AppAnnotationSetting,+ AppMode,+ AppModelConfig,+ Conversation,+ EndUser,+ Message,+ MessageFeedback,+)+from repositories.sqlalchemy_execution_extra_content_repository import SQLAlchemyExecutionExtraContentRepositoryfrom services.errors.message import (FirstMessageNotExistsError,LastMessageNotExistsError,@@ -16,1247 +38,819 @@ from services.errors.message import ()from services.message_service import MessageService, attach_message_extra_contents+SQLITE_MODELS = (Conversation, Message, MessageFeedback, AppModelConfig, AppAnnotationSetting)+pytestmark = [+ pytest.mark.usefixtures("sqlite_session"),+ pytest.mark.parametrize("sqlite_session", [SQLITE_MODELS], indirect=True),+]+++class _DatabaseBinding:+ """Expose the SQLite engine and shared session through the production DB interface."""++ engine: Engine+ session: scoped_session[Session]++ def __init__(self, engine: Engine, session: scoped_session[Session]) -> None:+ self.engine = engine+ self.session = session+-class TestMessageServiceFactory:- """Factory class for creating test data and mock objects for message service tests."""+class MessageServiceTestDataFactory:+ """Create real service inputs and persistent message-domain rows."""@staticmethod- def create_app_mock(+ def create_app(app_id: str = "app-123",- mode: str = AppMode.ADVANCED_CHAT.value,- name: str = "Test App",- ) -> MagicMock:- """Create a mock App object."""- app = MagicMock(spec=App)- app.id = app_id- app.mode = mode- app.name = name- return app+ mode: AppMode = AppMode.ADVANCED_CHAT,+ tenant_id: str = "tenant-123",+ ) -> App:+ return App(+ id=app_id,+ tenant_id=tenant_id,+ name="Test App",+ description="",+ mode=mode,+ enable_site=True,+ enable_api=True,+ max_active_requests=0,+ )++ @staticmethod+ def create_end_user(user_id: str = "user-456") -> EndUser:+ return EndUser(+ id=user_id,+ tenant_id="tenant-123",+ app_id="app-123",+ type=EndUserType.SERVICE_API,+ session_id="session-789",+ )@staticmethod- def create_end_user_mock(- user_id: str = "user-456",- session_id: str = "session-789",- ) -> MagicMock:- """Create a mock EndUser object."""- user = MagicMock(spec=EndUser)- user.id = user_id- user.session_id = session_id- return user+ def create_account(user_id: str = "account-123") -> Account:+ account = Account(name="Admin", email="[email protected]", status=AccountStatus.ACTIVE)+ account.id = user_id+ return account@staticmethod- def create_conversation_mock(+ def create_conversation(conversation_id: str = "conv-001",app_id: str = "app-123",- ) -> MagicMock:- """Create a mock Conversation object."""- conversation = MagicMock()- conversation.id = conversation_id- conversation.app_id = app_id+ *,+ app_model_config_id: str | None = None,+ override_model_configs: str | None = None,+ ) -> Conversation:+ conversation = Conversation(+ id=conversation_id,+ app_id=app_id,+ app_model_config_id=app_model_config_id,+ override_model_configs=override_model_configs,+ mode=AppMode.CHAT,+ name="Test conversation",+ status="normal",+ from_source=ConversationFromSource.API,+ from_end_user_id="user-456",+ )+ conversation._inputs = {}return conversation@staticmethod- def create_message_mock(+ def create_message(message_id: str = "msg-001",conversation_id: str = "conv-001",- query: str = "What is AI?",- answer: str = "AI stands for Artificial Intelligence.",+ app_id: str = "app-123",+ *,created_at: datetime | None = None,- ) -> MagicMock:- """Create a mock Message object."""- message = MagicMock(spec=Message)- message.id = message_id- message.conversation_id = conversation_id- message.query = query- message.answer = answer- message.created_at = created_at or datetime.now()- message.user_feedback_with_session.return_value = None- message.admin_feedback_with_session.return_value = None+ from_source: ConversationFromSource = ConversationFromSource.API,+ from_end_user_id: str | None = "user-456",+ from_account_id: str | None = None,+ ) -> Message:+ message = Message(+ id=message_id,+ app_id=app_id,+ conversation_id=conversation_id,+ query="What is AI?",+ message={"role": "user", "content": "What is AI?"},+ answer="AI stands for Artificial Intelligence.",+ message_unit_price=Decimal("0.0001"),+ answer_unit_price=Decimal("0.0002"),+ currency="USD",+ from_source=from_source,+ from_end_user_id=from_end_user_id,+ from_account_id=from_account_id,+ )+ message._inputs = {}+ timestamp = created_at or datetime.now()+ message.created_at = timestamp+ message.updated_at = timestampreturn message--class TestMessageServicePaginationByFirstId:- """- Unit tests for MessageService.pagination_by_first_id method.-- This test suite covers:- - Basic pagination with and without first_id- - Order handling (asc/desc)- - Edge cases (no user, no conversation, invalid first_id)- - Has_more flag logic- """-- @pytest.fixture- def factory(self):- """Provide test data factory."""- return TestMessageServiceFactory()-- # Test 01: No user provided- def test_pagination_by_first_id_no_user(self, factory: TestMessageServiceFactory):- """Test pagination returns empty result when no user is provided."""- # Arrange- app = factory.create_app_mock()-- # Act- result = MessageService.pagination_by_first_id(- app_model=app,- user=None,- conversation_id="conv-001",- first_id=None,- limit=10,- session=MagicMock(),+ @staticmethod+ def create_feedback(+ feedback_id: str,+ message: Message,+ *,+ source: FeedbackFromSource,+ rating: FeedbackRating = FeedbackRating.LIKE,+ ) -> MessageFeedback:+ feedback = MessageFeedback(+ app_id=message.app_id,+ conversation_id=message.conversation_id,+ message_id=message.id,+ rating=rating,+ from_source=source,+ from_end_user_id="user-456" if source == FeedbackFromSource.USER else None,+ from_account_id="account-123" if source == FeedbackFromSource.ADMIN else None,)+ feedback.id = feedback_id+ return feedback- # Assert- assert isinstance(result, InfiniteScrollPagination)- assert result.data == []- assert result.limit == 10- assert result.has_more is False- # Test 02: No conversation_id provided- def test_pagination_by_first_id_no_conversation(self, factory: TestMessageServiceFactory):- """Test pagination returns empty result when no conversation_id is provided."""- # Arrange- app = factory.create_app_mock()- user = factory.create_end_user_mock()+def factory() -> MessageServiceTestDataFactory:+ return MessageServiceTestDataFactory()- # Act- result = MessageService.pagination_by_first_id(- app_model=app,- user=user,- conversation_id="",- first_id=None,- limit=10,- session=MagicMock(),- )- # Assert- assert isinstance(result, InfiniteScrollPagination)- assert result.data == []- assert result.limit == 10- assert result.has_more is False[email protected](autouse=True)+def database_boundaries(+ monkeypatch: pytest.MonkeyPatch,+ sqlite_engine: Engine,+ sqlite_session: Session,+) -> Iterator[None]:+ """Bind global model properties and service-owned factories to the shared SQLite session."""+ sessions = scoped_session(lambda: sqlite_session)+ database = _DatabaseBinding(engine=sqlite_engine, session=sessions)+ monkeypatch.setattr(service_module, "db", database)+ monkeypatch.setattr(model_module, "db", database)+ try:+ yield+ finally:+ sessions.remove()+++def empty_extra_content_repository(monkeypatch: pytest.MonkeyPatch) -> MagicMock:+ repository = MagicMock()+ repository.get_by_message_ids.side_effect = lambda message_ids: [[] for _ in message_ids]+ monkeypatch.setattr(service_module, "_create_execution_extra_content_repository", lambda: repository)+ return repository- # Test 03: Basic pagination without first_id (desc order)- @patch("services.message_service._create_execution_extra_content_repository")- @patch("services.message_service.db")- @patch("services.message_service.ConversationService")- def test_pagination_by_first_id_without_first_id_desc(- self, mock_conversation_service, mock_db, mock_create_repo, factory: TestMessageServiceFactory- ):- """Test basic pagination without first_id in descending order."""- # Arrange- app = factory.create_app_mock()- user = factory.create_end_user_mock()- conversation = factory.create_conversation_mock()-- mock_conversation_service.get_conversation.return_value = conversation-- # Create 5 messages- messages = [- factory.create_message_mock(- message_id=f"msg-{i:03d}",- created_at=datetime(2024, 1, 1, 12, i),- )- for i in range(5)- ]- mock_db.session.scalars.return_value.all.return_value = messages+def _persist(session: Session, *records: object) -> None:+ session.add_all(records)+ session.commit()- # Act++def _patch_conversation(monkeypatch: pytest.MonkeyPatch, conversation: Conversation) -> MagicMock:+ get_conversation = MagicMock(return_value=conversation)+ monkeypatch.setattr(service_module.ConversationService, "get_conversation", get_conversation)+ return get_conversation+++class TestMessageServicePaginationByFirstId:+ """Verify cursor pagination using persisted message timestamps and IDs."""++ @pytest.mark.parametrize(("user", "conversation_id"), [(None, "conv-001"), ("end_user", "")])+ def test_early_return(+ self,+ user: str | None,+ conversation_id: str,+ factory: MessageServiceTestDataFactory,+ sqlite_session: Session,+ ) -> None:result = MessageService.pagination_by_first_id(- app_model=app,- user=user,- conversation_id="conv-001",+ app_model=factory.create_app(),+ user=factory.create_end_user() if user else None,+ conversation_id=conversation_id,first_id=None,limit=10,- order="desc",- session=mock_db.session,+ session=sqlite_session,)- # Assert- assert len(result.data) == 5- assert result.has_more is False+ assert result.data == []assert result.limit == 10- # Messages should remain in desc order (not reversed)- assert result.data[0].id == "msg-000"-- # Test 04: Basic pagination without first_id (asc order)- @patch("services.message_service._create_execution_extra_content_repository")- @patch("services.message_service.db")- @patch("services.message_service.ConversationService")- def test_pagination_by_first_id_without_first_id_asc(- self, mock_conversation_service, mock_db, mock_create_repo, factory: TestMessageServiceFactory- ):- """Test basic pagination without first_id in ascending order."""- # Arrange- app = factory.create_app_mock()- user = factory.create_end_user_mock()- conversation = factory.create_conversation_mock()-- mock_conversation_service.get_conversation.return_value = conversation-- # Create 5 messages (returned in desc order from DB)+ assert result.has_more is False++ @pytest.mark.parametrize(+ ("order", "expected_ids"),+ [+ ("desc", ["msg-004", "msg-003", "msg-002", "msg-001", "msg-000"]),+ ("asc", ["msg-000", "msg-001", "msg-002", "msg-003", "msg-004"]),+ ],+ )+ def test_orders_persisted_messages(+ self,+ order: str,+ expected_ids: list[str],+ monkeypatch: pytest.MonkeyPatch,+ factory: MessageServiceTestDataFactory,+ sqlite_session: Session,+ empty_extra_content_repository: MagicMock,+ ) -> None:+ conversation = factory.create_conversation()messages = [- factory.create_message_mock(- message_id=f"msg-{i:03d}",- created_at=datetime(2024, 1, 1, 12, 4 - i), # Descending timestamps- )- for i in range(5)+ factory.create_message(f"msg-{index:03d}", created_at=datetime(2024, 1, 1, 12, index)) for index in range(5)]+ _persist(sqlite_session, conversation, *messages)+ _patch_conversation(monkeypatch, conversation)- mock_db.session.scalars.return_value.all.return_value = messages-- # Actresult = MessageService.pagination_by_first_id(- app_model=app,- user=user,- conversation_id="conv-001",+ app_model=factory.create_app(),+ user=factory.create_end_user(),+ conversation_id=conversation.id,first_id=None,limit=10,- order="asc",- session=mock_db.session,+ order=order,+ session=sqlite_session,)- # Assert- assert len(result.data) == 5+ assert [message.id for message in result.data] == expected_idsassert result.has_more is False- # Messages should be reversed to asc order- assert result.data[0].id == "msg-004"- assert result.data[4].id == "msg-000"-- # Test 05: Pagination with first_id- @patch("services.message_service._create_execution_extra_content_repository")- @patch("services.message_service.db")- @patch("services.message_service.ConversationService")- def test_pagination_by_first_id_with_first_id(- self, mock_conversation_service, mock_db, mock_create_repo, factory: TestMessageServiceFactory- ):- """Test pagination with first_id to get messages before a specific message."""- # Arrange- app = factory.create_app_mock()- user = factory.create_end_user_mock()- conversation = factory.create_conversation_mock()-- mock_conversation_service.get_conversation.return_value = conversation-- first_message = factory.create_message_mock(- message_id="msg-005",- created_at=datetime(2024, 1, 1, 12, 5),- )- # Messages before first_message- history_messages = [- factory.create_message_mock(- message_id=f"msg-{i:03d}",- created_at=datetime(2024, 1, 1, 12, i),- )- for i in range(5)+ def test_first_id_excludes_cursor_and_newer_messages(+ self,+ monkeypatch: pytest.MonkeyPatch,+ factory: MessageServiceTestDataFactory,+ sqlite_session: Session,+ empty_extra_content_repository: MagicMock,+ ) -> None:+ conversation = factory.create_conversation()+ messages = [+ factory.create_message(f"msg-{index:03d}", created_at=datetime(2024, 1, 1, 12, index)) for index in range(7)]+ _persist(sqlite_session, conversation, *messages)+ _patch_conversation(monkeypatch, conversation)- mock_db.session.scalar.return_value = first_message- mock_db.session.scalars.return_value.all.return_value = history_messages-- # Actresult = MessageService.pagination_by_first_id(- app_model=app,- user=user,- conversation_id="conv-001",+ app_model=factory.create_app(),+ user=factory.create_end_user(),+ conversation_id=conversation.id,first_id="msg-005",limit=10,order="desc",- session=mock_db.session,+ session=sqlite_session,)- # Assert- assert len(result.data) == 5- assert result.has_more is False-- # Test 06: First message not found- @patch("services.message_service.db")- @patch("services.message_service.ConversationService")- def test_pagination_by_first_id_first_message_not_exists(- self, mock_conversation_service, mock_db, factory: TestMessageServiceFactory- ):- """Test error handling when first_id doesn't exist."""- # Arrange- app = factory.create_app_mock()- user = factory.create_end_user_mock()- conversation = factory.create_conversation_mock()+ assert [message.id for message in result.data] == [f"msg-{index:03d}" for index in range(4, -1, -1)]- mock_conversation_service.get_conversation.return_value = conversation-- mock_db.session.scalar.return_value = None # Message not found+ def test_missing_first_id_raises(+ self,+ monkeypatch: pytest.MonkeyPatch,+ factory: MessageServiceTestDataFactory,+ sqlite_session: Session,+ ) -> None:+ conversation = factory.create_conversation()+ _persist(sqlite_session, conversation)+ _patch_conversation(monkeypatch, conversation)- # Act & Assertwith pytest.raises(FirstMessageNotExistsError):MessageService.pagination_by_first_id(- app_model=app,- user=user,- conversation_id="conv-001",- first_id="nonexistent-msg",+ app_model=factory.create_app(),+ user=factory.create_end_user(),+ conversation_id=conversation.id,+ first_id="missing",limit=10,- session=mock_db.session,+ session=sqlite_session,)- # Test 07: Has_more flag when results exceed limit- @patch("services.message_service._create_execution_extra_content_repository")- @patch("services.message_service.db")- @patch("services.message_service.ConversationService")- def test_pagination_by_first_id_has_more_true(- self, mock_conversation_service, mock_db, mock_create_repo, factory: TestMessageServiceFactory- ):- """Test has_more flag is True when results exceed limit."""- # Arrange- app = factory.create_app_mock()- user = factory.create_end_user_mock()- conversation = factory.create_conversation_mock()-- mock_conversation_service.get_conversation.return_value = conversation-- # Create limit+1 messages (11 messages for limit=10)+ def test_has_more_trims_oldest_extra_row(+ self,+ monkeypatch: pytest.MonkeyPatch,+ factory: MessageServiceTestDataFactory,+ sqlite_session: Session,+ empty_extra_content_repository: MagicMock,+ ) -> None:+ conversation = factory.create_conversation()messages = [- factory.create_message_mock(- message_id=f"msg-{i:03d}",- created_at=datetime(2024, 1, 1, 12, i),- )- for i in range(11)+ factory.create_message(f"msg-{index:03d}", created_at=datetime(2024, 1, 1, 12, index))+ for index in range(11)]+ _persist(sqlite_session, conversation, *messages)+ _patch_conversation(monkeypatch, conversation)- mock_db.session.scalars.return_value.all.return_value = messages-- # Actresult = MessageService.pagination_by_first_id(- app_model=app,- user=user,- conversation_id="conv-001",+ app_model=factory.create_app(),+ user=factory.create_end_user(),+ conversation_id=conversation.id,first_id=None,limit=10,- session=mock_db.session,+ order="desc",+ session=sqlite_session,)- # Assert- assert len(result.data) == 10 # Last message trimmed+ assert len(result.data) == 10assert result.has_more is True- assert result.limit == 10-- # Test 08: Empty conversation- @patch("services.message_service.db")- @patch("services.message_service.ConversationService")- def test_pagination_by_first_id_empty_conversation(- self, mock_conversation_service, mock_db, factory: TestMessageServiceFactory- ):- """Test pagination with conversation that has no messages."""- # Arrange- app = factory.create_app_mock()- user = factory.create_end_user_mock()- conversation = factory.create_conversation_mock()+ assert result.data[-1].id == "msg-001"- mock_conversation_service.get_conversation.return_value = conversation-- mock_db.session.scalars.return_value.all.return_value = []+ def test_empty_conversation(+ self,+ monkeypatch: pytest.MonkeyPatch,+ factory: MessageServiceTestDataFactory,+ sqlite_session: Session,+ empty_extra_content_repository: MagicMock,+ ) -> None:+ conversation = factory.create_conversation()+ _persist(sqlite_session, conversation)+ _patch_conversation(monkeypatch, conversation)- # Actresult = MessageService.pagination_by_first_id(- app_model=app,- user=user,- conversation_id="conv-001",+ app_model=factory.create_app(),+ user=factory.create_end_user(),+ conversation_id=conversation.id,first_id=None,limit=10,- session=mock_db.session,+ session=sqlite_session,)- # Assert- assert len(result.data) == 0+ assert result.data == []assert result.has_more is False- assert result.limit == 10class TestMessageServicePaginationByLastId:- """- Unit tests for MessageService.pagination_by_last_id method.-- This test suite covers:- - Basic pagination with and without last_id- - Conversation filtering- - Include_ids filtering- - Edge cases (no user, invalid last_id)- """-- @pytest.fixture- def factory(self):- """Provide test data factory."""- return TestMessageServiceFactory()-- # Test 09: No user provided- def test_pagination_by_last_id_no_user(self, factory: TestMessageServiceFactory):- """Test pagination returns empty result when no user is provided."""- # Arrange- app = factory.create_app_mock()-- # Act+ """Verify reverse cursor, conversation, and include-ID filtering."""++ def test_no_user(self, factory: MessageServiceTestDataFactory, sqlite_session: Session) -> None:result = MessageService.pagination_by_last_id(- app_model=app,- user=None,- last_id=None,- limit=10,- session=MagicMock(),+ app_model=factory.create_app(), user=None, last_id=None, limit=10, session=sqlite_session)-- # Assert- assert isinstance(result, InfiniteScrollPagination)assert result.data == []assert result.limit == 10assert result.has_more is False- # Test 10: Basic pagination without last_id- @patch("services.message_service.db")- def test_pagination_by_last_id_without_last_id(self, mock_db, factory: TestMessageServiceFactory):- """Test basic pagination without last_id."""- # Arrange- app = factory.create_app_mock()- user = factory.create_end_user_mock()-+ def test_without_last_id(self, factory: MessageServiceTestDataFactory, sqlite_session: Session) -> None:messages = [- factory.create_message_mock(- message_id=f"msg-{i:03d}",- created_at=datetime(2024, 1, 1, 12, i),- )- for i in range(5)+ factory.create_message(f"msg-{index:03d}", created_at=datetime(2024, 1, 1, 12, index)) for index in range(5)]+ _persist(sqlite_session, *messages)- mock_db.session.scalars.return_value.all.return_value = messages-- # Actresult = MessageService.pagination_by_last_id(- app_model=app,- user=user,+ app_model=factory.create_app(),+ user=factory.create_end_user(),last_id=None,limit=10,- session=mock_db.session,+ session=sqlite_session,)- # Assert- assert len(result.data) == 5+ assert [message.id for message in result.data] == [f"msg-{index:03d}" for index in range(4, -1, -1)]assert result.has_more is False- assert result.limit == 10-- # Test 11: Pagination with last_id- @patch("services.message_service.db")- def test_pagination_by_last_id_with_last_id(self, mock_db, factory: TestMessageServiceFactory):- """Test pagination with last_id to get messages after a specific message."""- # Arrange- app = factory.create_app_mock()- user = factory.create_end_user_mock()-- last_message = factory.create_message_mock(- message_id="msg-005",- created_at=datetime(2024, 1, 1, 12, 5),- )- # Messages after last_message- new_messages = [- factory.create_message_mock(- message_id=f"msg-{i:03d}",- created_at=datetime(2024, 1, 1, 12, i),- )- for i in range(6, 10)+ def test_last_id_returns_older_rows(self, factory: MessageServiceTestDataFactory, sqlite_session: Session) -> None:+ messages = [+ factory.create_message(f"msg-{index:03d}", created_at=datetime(2024, 1, 1, 12, index)) for index in range(7)]+ _persist(sqlite_session, *messages)- mock_db.session.scalar.return_value = last_message- mock_db.session.scalars.return_value.all.return_value = new_messages-- # Actresult = MessageService.pagination_by_last_id(- app_model=app,- user=user,+ app_model=factory.create_app(),+ user=factory.create_end_user(),last_id="msg-005",limit=10,- session=mock_db.session,+ session=sqlite_session,)- # Assert- assert len(result.data) == 4- assert result.has_more is False-- # Test 12: Last message not found- @patch("services.message_service.db")- def test_pagination_by_last_id_last_message_not_exists(self, mock_db, factory: TestMessageServiceFactory):- """Test error handling when last_id doesn't exist."""- # Arrange- app = factory.create_app_mock()- user = factory.create_end_user_mock()-- mock_db.session.scalar.return_value = None # Message not found+ assert [message.id for message in result.data] == [f"msg-{index:03d}" for index in range(4, -1, -1)]- # Act & Assert+ def test_missing_last_id_raises(self, factory: MessageServiceTestDataFactory, sqlite_session: Session) -> None:with pytest.raises(LastMessageNotExistsError):MessageService.pagination_by_last_id(- app_model=app,- user=user,- last_id="nonexistent-msg",+ app_model=factory.create_app(),+ user=factory.create_end_user(),+ last_id="missing",limit=10,- session=mock_db.session,+ session=sqlite_session,)- # Test 13: Pagination with conversation_id filter- @patch("services.message_service.ConversationService")- @patch("services.message_service.db")- def test_pagination_by_last_id_with_conversation_filter(- self, mock_db, mock_conversation_service, factory: TestMessageServiceFactory- ):- """Test pagination filtered by conversation_id."""- # Arrange- app = factory.create_app_mock()- user = factory.create_end_user_mock()- conversation = factory.create_conversation_mock(conversation_id="conv-001")-- mock_conversation_service.get_conversation.return_value = conversation-- messages = [- factory.create_message_mock(- message_id=f"msg-{i:03d}",- conversation_id="conv-001",- created_at=datetime(2024, 1, 1, 12, i),- )- for i in range(5)- ]-- mock_db.session.scalars.return_value.all.return_value = messages+ def test_conversation_filter(+ self,+ monkeypatch: pytest.MonkeyPatch,+ factory: MessageServiceTestDataFactory,+ sqlite_session: Session,+ ) -> None:+ conversation = factory.create_conversation()+ other_conversation = factory.create_conversation("conv-002")+ matching = factory.create_message("matching", conversation_id=conversation.id)+ excluded = factory.create_message("excluded", conversation_id=other_conversation.id)+ _persist(sqlite_session, conversation, other_conversation, matching, excluded)+ get_conversation = _patch_conversation(monkeypatch, conversation)- # Actresult = MessageService.pagination_by_last_id(- app_model=app,- user=user,+ app_model=factory.create_app(),+ user=factory.create_end_user(),last_id=None,limit=10,- conversation_id="conv-001",- session=mock_db.session,+ conversation_id=conversation.id,+ session=sqlite_session,)- # Assert- assert len(result.data) == 5- assert result.has_more is False- mock_conversation_service.get_conversation.assert_called_once()-- # Test 14: Pagination with include_ids filter- @patch("services.message_service.db")- def test_pagination_by_last_id_with_include_ids(self, mock_db, factory: TestMessageServiceFactory):- """Test pagination filtered by include_ids."""- # Arrange- app = factory.create_app_mock()- user = factory.create_end_user_mock()+ assert [message.id for message in result.data] == [matching.id]+ get_conversation.assert_called_once()- # Only messages with IDs in include_ids should be returned+ def test_include_ids_filter(self, factory: MessageServiceTestDataFactory, sqlite_session: Session) -> None:messages = [- factory.create_message_mock(message_id="msg-001"),- factory.create_message_mock(message_id="msg-003"),+ factory.create_message(f"msg-{index:03d}", created_at=datetime(2024, 1, 1, 12, index)) for index in range(4)]+ _persist(sqlite_session, *messages)- mock_db.session.scalars.return_value.all.return_value = messages-- # Actresult = MessageService.pagination_by_last_id(- app_model=app,- user=user,+ app_model=factory.create_app(),+ user=factory.create_end_user(),last_id=None,limit=10,include_ids=["msg-001", "msg-003"],- session=mock_db.session,+ session=sqlite_session,)- # Assert- assert len(result.data) == 2- assert result.data[0].id == "msg-001"- assert result.data[1].id == "msg-003"-- # Test 15: Has_more flag when results exceed limit- @patch("services.message_service.db")- def test_pagination_by_last_id_has_more_true(self, mock_db, factory: TestMessageServiceFactory):- """Test has_more flag is True when results exceed limit."""- # Arrange- app = factory.create_app_mock()- user = factory.create_end_user_mock()+ assert [message.id for message in result.data] == ["msg-003", "msg-001"]- # Create limit+1 messages (11 messages for limit=10)+ def test_has_more(self, factory: MessageServiceTestDataFactory, sqlite_session: Session) -> None:messages = [- factory.create_message_mock(- message_id=f"msg-{i:03d}",- created_at=datetime(2024, 1, 1, 12, i),- )- for i in range(11)+ factory.create_message(f"msg-{index:03d}", created_at=datetime(2024, 1, 1, 12, index))+ for index in range(11)]+ _persist(sqlite_session, *messages)- mock_db.session.scalars.return_value.all.return_value = messages-- # Actresult = MessageService.pagination_by_last_id(- app_model=app,- user=user,+ app_model=factory.create_app(),+ user=factory.create_end_user(),last_id=None,limit=10,- session=mock_db.session,+ session=sqlite_session,)- # Assert- assert len(result.data) == 10 # Last message trimmed+ assert len(result.data) == 10assert result.has_more is True- assert result.limit == 10class TestMessageServiceUtilities:- """Unit tests for MessageService module-level utility functions."""-- @pytest.fixture- def factory(self):- """Provide test data factory."""- return TestMessageServiceFactory()-- # Test 16: attach_message_extra_contents with empty list- def test_attach_message_extra_contents_empty(self):- """Test attach_message_extra_contents with empty list does nothing."""- # Act & Assert (should not raise error)+ def test_attach_message_extra_contents_empty(self) -> None:attach_message_extra_contents([])- # Test 17: attach_message_extra_contents with messages- @patch("services.message_service._create_execution_extra_content_repository")- def test_attach_message_extra_contents_with_messages(self, mock_create_repo, factory: TestMessageServiceFactory):- """Test attach_message_extra_contents correctly attaches content."""- # Arrange- messages = [factory.create_message_mock(message_id="msg-1"), factory.create_message_mock(message_id="msg-2")]-- mock_repo = MagicMock()- mock_create_repo.return_value = mock_repo-- # Mock extra content models- mock_content1 = MagicMock()- mock_content1.model_dump.return_value = {"key": "value1"}- mock_content2 = MagicMock()- mock_content2.model_dump.return_value = {"key": "value2"}-- mock_repo.get_by_message_ids.return_value = [[mock_content1], [mock_content2]]-- # Act- attach_message_extra_contents(messages)+ def test_attach_message_extra_contents(+ self,+ monkeypatch: pytest.MonkeyPatch,+ factory: MessageServiceTestDataFactory,+ ) -> None:+ messages = [factory.create_message("msg-1"), factory.create_message("msg-2")]+ content_one = MagicMock()+ content_one.model_dump.return_value = {"key": "value1"}+ content_two = MagicMock()+ content_two.model_dump.return_value = {"key": "value2"}+ repository = MagicMock()+ repository.get_by_message_ids.return_value = [[content_one], [content_two]]+ monkeypatch.setattr(service_module, "_create_execution_extra_content_repository", lambda: repository)- # Assert- mock_repo.get_by_message_ids.assert_called_once_with(["msg-1", "msg-2"])- messages[0].set_extra_contents.assert_called_once_with([{"key": "value1"}])- messages[1].set_extra_contents.assert_called_once_with([{"key": "value2"}])-- # Test 18: attach_message_extra_contents with index out of bounds- @patch("services.message_service._create_execution_extra_content_repository")- def test_attach_message_extra_contents_index_out_of_bounds(- self, mock_create_repo, factory: TestMessageServiceFactory- ):- """Test attach_message_extra_contents handles missing content lists."""- # Arrange- messages = [factory.create_message_mock(message_id="msg-1")]-- mock_repo = MagicMock()- mock_create_repo.return_value = mock_repo- mock_repo.get_by_message_ids.return_value = [] # Empty returned list-- # Actattach_message_extra_contents(messages)- # Assert- messages[0].set_extra_contents.assert_called_once_with([])-- # Test 19: _create_execution_extra_content_repository- @patch("services.message_service.db")- @patch("services.message_service.sessionmaker")- @patch("services.message_service.SQLAlchemyExecutionExtraContentRepository")- def test_create_execution_extra_content_repository(self, mock_repo_class, mock_sessionmaker, mock_db):- """Test _create_execution_extra_content_repository creates expected repository."""- from services.message_service import _create_execution_extra_content_repository-- # Act- _create_execution_extra_content_repository()-- # Assert- mock_sessionmaker.assert_called_once()- mock_repo_class.assert_called_once()+ assert messages[0].extra_contents == [{"key": "value1"}]+ assert messages[1].extra_contents == [{"key": "value2"}]+ def test_attach_message_extra_contents_missing_list(+ self,+ monkeypatch: pytest.MonkeyPatch,+ factory: MessageServiceTestDataFactory,+ ) -> None:+ message = factory.create_message("msg-1")+ repository = MagicMock()+ repository.get_by_message_ids.return_value = []+ monkeypatch.setattr(service_module, "_create_execution_extra_content_repository", lambda: repository)-class TestMessageServiceGetMessage:- """Unit tests for MessageService.get_message method."""-- @pytest.fixture- def factory(self):- """Provide test data factory."""- return TestMessageServiceFactory()-- # Test 20: get_message success for EndUser- @patch("services.message_service.db")- def test_get_message_end_user_success(self, mock_db, factory: TestMessageServiceFactory):- """Test get_message returns message for EndUser."""- # Arrange- app = factory.create_app_mock()- user = factory.create_end_user_mock(user_id="end-user-123")- message = factory.create_message_mock()-- mock_db.session.scalar.return_value = message-- # Act,- result = MessageService.get_message(app_model=app, user=user, message_id="msg-123", session=mock_db.session)-- # Assert- assert result == message+ attach_message_extra_contents([message])- # Test 21: get_message success for Account (Admin)- @patch("services.message_service.db")- def test_get_message_account_success(self, mock_db, factory: TestMessageServiceFactory):- """Test get_message returns message for Account."""- # Arrange- from models import Account+ assert message.extra_contents == []- app = factory.create_app_mock()- user = MagicMock(spec=Account)- user.id = "account-123"- message = factory.create_message_mock()+ def test_create_execution_extra_content_repository_uses_sqlite_factory(self, sqlite_engine: Engine) -> None:+ repository = service_module._create_execution_extra_content_repository()- mock_db.session.scalar.return_value = message+ assert isinstance(repository, SQLAlchemyExecutionExtraContentRepository)+ assert repository._session_maker.kw["bind"] is sqlite_engine+ with repository._session_maker() as session:+ assert isinstance(session, Session)- # Act,- result = MessageService.get_message(app_model=app, user=user, message_id="msg-123", session=mock_db.session)- # Assert- assert result == message+class TestMessageServiceGetMessage:+ @pytest.mark.parametrize("actor", ["end_user", "account"])+ def test_identity_scoped_success(+ self,+ actor: str,+ factory: MessageServiceTestDataFactory,+ sqlite_session: Session,+ ) -> None:+ if actor == "end_user":+ user: Account | EndUser = factory.create_end_user("end-user-123")+ message = factory.create_message(+ "msg-123", from_end_user_id=user.id, from_account_id=None, from_source=ConversationFromSource.API+ )+ else:+ user = factory.create_account("account-123")+ message = factory.create_message(+ "msg-123",+ from_end_user_id=None,+ from_account_id=user.id,+ from_source=ConversationFromSource.CONSOLE,+ )+ distractor = factory.create_message("wrong-app", app_id="app-456")+ _persist(sqlite_session, message, distractor)- # Test 22: get_message not found- @patch("services.message_service.db")- def test_get_message_not_found(self, mock_db, factory: TestMessageServiceFactory):- """Test get_message raises MessageNotExistsError when not found."""- # Arrange- app = factory.create_app_mock()- user = factory.create_end_user_mock()+ result = MessageService.get_message(+ app_model=factory.create_app(), user=user, message_id=message.id, session=sqlite_session+ )- mock_db.session.scalar.return_value = None+ assert result.id == message.id- # Act & Assert+ def test_not_found(self, factory: MessageServiceTestDataFactory, sqlite_session: Session) -> None:with pytest.raises(MessageNotExistsError):- MessageService.get_message(app_model=app, user=user, message_id="msg-123", session=mock_db.session)+ MessageService.get_message(+ app_model=factory.create_app(),+ user=factory.create_end_user(),+ message_id="missing",+ session=sqlite_session,+ )class TestMessageServiceFeedback:- """Unit tests for MessageService feedback-related methods."""-- @pytest.fixture- def factory(self):- """Provide test data factory."""- return TestMessageServiceFactory()-- # Test 23: create_feedback - new feedback for EndUser- @patch("services.message_service.db")- @patch.object(MessageService, "get_message")- def test_create_feedback_new_end_user(self, mock_get_message, mock_db, factory: TestMessageServiceFactory):- """Test creating new feedback for an end user."""- # Arrange- app = factory.create_app_mock()- user = factory.create_end_user_mock()- message = factory.create_message_mock()- message.user_feedback = None- message.user_feedback_with_session.return_value = None- mock_get_message.return_value = message-- # Act- result = MessageService.create_feedback(- app_model=app,- message_id="msg-123",+ def test_create_new_end_user_feedback(+ self,+ factory: MessageServiceTestDataFactory,+ sqlite_session: Session,+ sqlite_engine: Engine,+ ) -> None:+ user = factory.create_end_user()+ message = factory.create_message("msg-123")+ _persist(sqlite_session, message)++ feedback = MessageService.create_feedback(+ app_model=factory.create_app(),+ message_id=message.id,user=user,rating=FeedbackRating.LIKE,content="Good answer",- session=mock_db.session,+ session=sqlite_session,+ )++ with Session(sqlite_engine) as verification_session:+ persisted = verification_session.get(MessageFeedback, feedback.id)+ assert persisted is not None+ assert persisted.rating == FeedbackRating.LIKE+ assert persisted.content == "Good answer"+ assert persisted.from_source == FeedbackFromSource.USER++ def test_update_account_feedback(+ self,+ factory: MessageServiceTestDataFactory,+ sqlite_session: Session,+ sqlite_engine: Engine,+ ) -> None:+ user = factory.create_account()+ message = factory.create_message(+ "msg-123",+ from_source=ConversationFromSource.CONSOLE,+ from_end_user_id=None,+ from_account_id=user.id,)+ feedback = factory.create_feedback("feedback-1", message, source=FeedbackFromSource.ADMIN)+ _persist(sqlite_session, message, feedback)- # Assert- assert result.rating == FeedbackRating.LIKE- assert result.content == "Good answer"- assert result.from_source == FeedbackFromSource.USER- mock_db.session.add.assert_called_once()- mock_db.session.commit.assert_called_once()-- # Test 24: create_feedback - update feedback for Account- @patch("services.message_service.db")- @patch.object(MessageService, "get_message")- def test_create_feedback_update_account(self, mock_get_message, mock_db, factory: TestMessageServiceFactory):- """Test updating existing feedback for an account."""- # Arrange- from models import Account, MessageFeedback-- app = factory.create_app_mock()- user = MagicMock(spec=Account)- user.id = "account-123"- message = factory.create_message_mock()- feedback = MagicMock(spec=MessageFeedback)- message.admin_feedback = feedback- message.admin_feedback_with_session.return_value = feedback- mock_get_message.return_value = message-- # Actresult = MessageService.create_feedback(- app_model=app,- message_id="msg-123",+ app_model=factory.create_app(),+ message_id=message.id,user=user,rating=FeedbackRating.DISLIKE,content="Bad answer",- session=mock_db.session,+ session=sqlite_session,)- # Assert- assert result == feedback- assert feedback.rating == FeedbackRating.DISLIKE- assert feedback.content == "Bad answer"- mock_db.session.commit.assert_called_once()-- # Test 25: create_feedback - delete feedback (rating is None)- @patch("services.message_service.db")- @patch.object(MessageService, "get_message")- def test_create_feedback_delete(self, mock_get_message, mock_db, factory: TestMessageServiceFactory):- """Test deleting feedback by passing rating=None."""- # Arrange- app = factory.create_app_mock()- user = factory.create_end_user_mock()- message = factory.create_message_mock()- feedback = MagicMock()- message.user_feedback = feedback- message.user_feedback_with_session.return_value = feedback- mock_get_message.return_value = message-- # Act- result = MessageService.create_feedback(- app_model=app,- message_id="msg-123",+ assert result.id == feedback.id+ with Session(sqlite_engine) as verification_session:+ persisted = verification_session.get(MessageFeedback, feedback.id)+ assert persisted is not None+ assert persisted.rating == FeedbackRating.DISLIKE+ assert persisted.content == "Bad answer"++ def test_delete_feedback(+ self,+ factory: MessageServiceTestDataFactory,+ sqlite_session: Session,+ sqlite_engine: Engine,+ ) -> None:+ user = factory.create_end_user()+ message = factory.create_message("msg-123")+ feedback = factory.create_feedback("feedback-1", message, source=FeedbackFromSource.USER)+ _persist(sqlite_session, message, feedback)++ MessageService.create_feedback(+ app_model=factory.create_app(),+ message_id=message.id,user=user,rating=None,content=None,- session=mock_db.session,+ session=sqlite_session,)- # Assert- assert result == feedback- mock_db.session.delete.assert_called_once_with(feedback)- mock_db.session.commit.assert_called_once()-- # Test 26: get_all_messages_feedbacks- @patch("services.message_service.db")- def test_get_all_messages_feedbacks(self, mock_db, factory: TestMessageServiceFactory):- """Test get_all_messages_feedbacks returns list of dicts."""- # Arrange- app = factory.create_app_mock()- feedback = MagicMock()- feedback.to_dict.return_value = {"id": "fb-1"}-- mock_db.session.scalars.return_value.all.return_value = [feedback]+ with Session(sqlite_engine) as verification_session:+ assert verification_session.get(MessageFeedback, feedback.id) is None- # Act,- result = MessageService.get_all_messages_feedbacks(app_model=app, page=1, limit=10, session=mock_db.session)+ def test_get_all_feedbacks_is_app_scoped_and_paginated(+ self,+ factory: MessageServiceTestDataFactory,+ sqlite_session: Session,+ ) -> None:+ message = factory.create_message("msg-123")+ newest = factory.create_feedback("feedback-new", message, source=FeedbackFromSource.USER)+ oldest = factory.create_feedback("feedback-old", message, source=FeedbackFromSource.USER)+ other_message = factory.create_message("other-msg", app_id="app-456")+ other_app = factory.create_feedback("feedback-other", other_message, source=FeedbackFromSource.USER)+ newest.created_at = datetime(2024, 1, 2)+ oldest.created_at = datetime(2024, 1, 1)+ other_app.created_at = datetime(2024, 1, 3)+ _persist(sqlite_session, newest, oldest, other_app)++ result = MessageService.get_all_messages_feedbacks(+ app_model=factory.create_app(), page=1, limit=1, session=sqlite_session+ )- # Assert- assert result == [{"id": "fb-1"}]+ assert [record["id"] for record in result] == [newest.id]class TestMessageServiceSuggestedQuestions:- """Unit tests for MessageService.get_suggested_questions_after_answer method."""-- @pytest.fixture- def factory(self):- """Provide test data factory."""- return TestMessageServiceFactory()-- # Test 27: get_suggested_questions_after_answer - user is None- def test_get_suggested_questions_user_none(self, factory: TestMessageServiceFactory):- app = factory.create_app_mock()+ @staticmethod+ def _chat_boundaries(+ monkeypatch: pytest.MonkeyPatch,+ conversation: Conversation,+ ) -> tuple[MagicMock, MagicMock, MagicMock]:+ message = MagicMock()+ message.conversation_id = conversation.id+ monkeypatch.setattr(service_module.MessageService, "get_message", MagicMock(return_value=message))+ monkeypatch.setattr(+ service_module.ConversationService, "get_conversation", MagicMock(return_value=conversation)+ )+ model_manager = MagicMock()+ monkeypatch.setattr(service_module.ModelManager, "for_tenant", MagicMock(return_value=model_manager))+ memory = MagicMock()+ memory.return_value.get_history_prompt_text.return_value = "histories"+ monkeypatch.setattr(service_module, "TokenBufferMemory", memory)+ llm_generator = MagicMock()+ llm_generator.generate_suggested_questions_after_answer.return_value = ["Q1?"]+ monkeypatch.setattr(service_module, "LLMGenerator", llm_generator)+ monkeypatch.setattr(service_module, "TraceQueueManager", MagicMock())+ return model_manager, memory, llm_generator++ def test_user_none(self, factory: MessageServiceTestDataFactory, sqlite_session: Session) -> None:with pytest.raises(ValueError, match="user cannot be None"):MessageService.get_suggested_questions_after_answer(- app_model=app,+ app_model=factory.create_app(),user=None,message_id="msg-123",- invoke_from=MagicMock(),- session=MagicMock(),+ invoke_from=InvokeFrom.WEB_APP,+ session=sqlite_session,)- # Test 28: get_suggested_questions_after_answer - Advanced Chat success- @patch("services.message_service.ModelManager.for_tenant")- @patch("services.message_service.WorkflowService")- @patch("services.message_service.AdvancedChatAppConfigManager")- @patch("services.message_service.TokenBufferMemory")- @patch("services.message_service.LLMGenerator")- @patch("services.message_service.TraceQueueManager")- @patch.object(MessageService, "get_message")- @patch("services.message_service.ConversationService")- def test_get_suggested_questions_advanced_chat_success(+ def test_advanced_chat_success(self,- mock_conversation_service,- mock_get_message,- mock_trace_manager,- mock_llm_gen,- mock_memory,- mock_config_manager,- mock_workflow_service,- mock_model_manager,- factory: TestMessageServiceFactory,- ):- """Test successful suggested questions generation in Advanced Chat mode."""- from core.app.entities.app_invoke_entities import InvokeFrom-- # Arrange- app = factory.create_app_mock(mode=AppMode.ADVANCED_CHAT.value)- user = factory.create_end_user_mock()- message = factory.create_message_mock()- mock_get_message.return_value = message-+ monkeypatch: pytest.MonkeyPatch,+ factory: MessageServiceTestDataFactory,+ sqlite_session: Session,+ ) -> None:+ conversation = factory.create_conversation()+ _, _, llm_generator = self._chat_boundaries(monkeypatch, conversation)workflow = MagicMock()- mock_workflow_service.return_value.get_published_workflow.return_value = workflow-- app_config = MagicMock()- app_config.additional_features.suggested_questions_after_answer = True- mock_config_manager.get_app_config.return_value = app_config-- mock_llm_gen.generate_suggested_questions_after_answer.return_value = ["Q1?"]+ workflow.features_dict = {"suggested_questions_after_answer": {"enabled": True}}+ workflow_service = MagicMock()+ workflow_service.return_value.get_published_workflow.return_value = workflow+ monkeypatch.setattr(service_module, "WorkflowService", workflow_service)+ app_config_manager = MagicMock()+ app_config_manager.get_app_config.return_value.additional_features.suggested_questions_after_answer = True+ monkeypatch.setattr(service_module, "AdvancedChatAppConfigManager", app_config_manager)- # Actresult = MessageService.get_suggested_questions_after_answer(- app_model=app,- user=user,+ app_model=factory.create_app(mode=AppMode.ADVANCED_CHAT),+ user=factory.create_end_user(),message_id="msg-123",invoke_from=InvokeFrom.WEB_APP,- session=MagicMock(),+ session=sqlite_session,)- # Assertassert result == ["Q1?"]- mock_workflow_service.return_value.get_published_workflow.assert_called_once()- mock_llm_gen.generate_suggested_questions_after_answer.assert_called_once()-- # Test 29: get_suggested_questions_after_answer - Chat app success (no override)- @patch("services.message_service.db")- @patch("services.message_service.ModelManager.for_tenant")- @patch("services.message_service.TokenBufferMemory")- @patch("services.message_service.LLMGenerator")- @patch("services.message_service.TraceQueueManager")- @patch.object(MessageService, "get_message")- @patch("services.message_service.ConversationService")- def test_get_suggested_questions_chat_app_success(+ llm_generator.generate_suggested_questions_after_answer.assert_called_once()++ @pytest.mark.parametrize(+ ("config", "expected_prompt", "expected_model"),+ [+ ({"enabled": True}, None, None),+ (+ {+ "enabled": True,+ "prompt": "custom prompt",+ "model": {+ "provider": "openai",+ "name": "gpt-4o-mini",+ "completion_params": {"max_tokens": 2048, "temperature": 0.1},+ },+ },+ "custom prompt",+ {+ "provider": "openai",+ "name": "gpt-4o-mini",+ "completion_params": {"max_tokens": 2048, "temperature": 0.1},+ },+ ),+ (+ {"enabled": True, "model": {"provider": "openai", "name": "invalid-model"}},+ None,+ {"provider": "openai", "name": "invalid-model"},+ ),+ ],+ )+ def test_chat_app_uses_persisted_model_config(self,- mock_conversation_service: MagicMock,- mock_get_message: MagicMock,- mock_trace_manager: MagicMock,- mock_llm_gen: MagicMock,- mock_memory: MagicMock,- mock_model_manager: MagicMock,- mock_db: MagicMock,- factory: TestMessageServiceFactory,- ):- """Test successful suggested questions generation in basic Chat mode."""- # Arrange- app = factory.create_app_mock(mode=AppMode.CHAT)- user = factory.create_end_user_mock()- message = factory.create_message_mock()- mock_get_message.return_value = message-- conversation = MagicMock()- conversation.override_model_configs = None- mock_conversation_service.get_conversation.return_value = conversation-- app_model_config = MagicMock()- app_model_config.suggested_questions_after_answer_dict = {"enabled": True}- app_model_config.model_dict = {"provider": "openai", "name": "gpt-4"}-- mock_db.session.scalar.return_value = app_model_config-- mock_llm_gen.generate_suggested_questions_after_answer.return_value = ["Q1?"]-- # Act- result = MessageService.get_suggested_questions_after_answer(- app_model=app,- user=user,- message_id="msg-123",- invoke_from=MagicMock(),- session=mock_db.session,+ config: dict[str, object],+ expected_prompt: str | None,+ expected_model: dict[str, object] | None,+ monkeypatch: pytest.MonkeyPatch,+ factory: MessageServiceTestDataFactory,+ sqlite_session: Session,+ ) -> None:+ app_model_config = AppModelConfig(+ app_id="app-123",+ suggested_questions_after_answer=json.dumps(config),)-- # Assert- assert result == ["Q1?"]- mock_llm_gen.generate_suggested_questions_after_answer.assert_called_once()-- @patch("services.message_service.db")- @patch("services.message_service.ModelManager.for_tenant")- @patch("services.message_service.TokenBufferMemory")- @patch("services.message_service.LLMGenerator")- @patch("services.message_service.TraceQueueManager")- @patch.object(MessageService, "get_message")- @patch("services.message_service.ConversationService")- def test_get_suggested_questions_chat_app_uses_frontend_model_and_prompt(- self,- mock_conversation_service: MagicMock,- mock_get_message: MagicMock,- mock_trace_manager: MagicMock,- mock_llm_gen: MagicMock,- mock_memory: MagicMock,- mock_model_manager: MagicMock,- mock_db: MagicMock,- factory: TestMessageServiceFactory,- ):- """Test suggested question generation uses frontend configured model and prompt."""- from core.app.entities.app_invoke_entities import InvokeFrom-- app = factory.create_app_mock(mode=AppMode.CHAT)- app.tenant_id = "tenant-123"- user = factory.create_end_user_mock()- message = factory.create_message_mock()- mock_get_message.return_value = message-- conversation = MagicMock()- conversation.override_model_configs = None- mock_conversation_service.get_conversation.return_value = conversation-- app_model_config = MagicMock()- app_model_config.suggested_questions_after_answer_dict = {- "enabled": True,- "prompt": "custom prompt",- "model": {- "provider": "openai",- "name": "gpt-4o-mini",- "completion_params": {"max_tokens": 2048, "temperature": 0.1},- },- }- mock_db.session.scalar.return_value = app_model_config-- mock_memory.return_value.get_history_prompt_text.return_value = "histories"- mock_llm_gen.generate_suggested_questions_after_answer.return_value = ["Q1?"]+ app_model_config.id = "config-1"+ conversation = factory.create_conversation(app_model_config_id=app_model_config.id)+ _persist(sqlite_session, app_model_config)+ model_manager, memory, llm_generator = self._chat_boundaries(monkeypatch, conversation)result = MessageService.get_suggested_questions_after_answer(- app_model=app,- user=user,+ app_model=factory.create_app(mode=AppMode.CHAT),+ user=factory.create_end_user(),message_id="msg-123",invoke_from=InvokeFrom.WEB_APP,- session=mock_db.session,+ session=sqlite_session,)assert result == ["Q1?"]- mock_model_manager.return_value.get_default_model_instance.assert_called_once_with(- tenant_id="tenant-123",- model_type=ModelType.LLM,+ model_manager.get_default_model_instance.assert_called_once_with(+ tenant_id="tenant-123", model_type=ModelType.LLM)- mock_memory.assert_called_once_with(+ memory.assert_called_once_with(conversation=conversation,- model_instance=mock_model_manager.return_value.get_default_model_instance.return_value,+ model_instance=model_manager.get_default_model_instance.return_value,)- mock_llm_gen.generate_suggested_questions_after_answer.assert_called_once_with(+ llm_generator.generate_suggested_questions_after_answer.assert_called_once_with(tenant_id="tenant-123",histories="histories",- instruction_prompt="custom prompt",- model_config={- "provider": "openai",- "name": "gpt-4o-mini",- "completion_params": {"max_tokens": 2048, "temperature": 0.1},- },- )-- @patch("services.message_service.db")- @patch("services.message_service.ModelManager.for_tenant")- @patch("services.message_service.TokenBufferMemory")- @patch("services.message_service.LLMGenerator")- @patch("services.message_service.TraceQueueManager")- @patch.object(MessageService, "get_message")- @patch("services.message_service.ConversationService")- def test_get_suggested_questions_chat_app_invalid_frontend_model_fallback_to_default(- self,- mock_conversation_service: MagicMock,- mock_get_message: MagicMock,- mock_trace_manager: MagicMock,- mock_llm_gen: MagicMock,- mock_memory: MagicMock,- mock_model_manager: MagicMock,- mock_db: MagicMock,- factory: TestMessageServiceFactory,- ):- """Test invalid frontend configured model falls back to tenant default model."""- app = factory.create_app_mock(mode=AppMode.CHAT)- app.tenant_id = "tenant-123"- user = factory.create_end_user_mock()- message = factory.create_message_mock()- mock_get_message.return_value = message-- conversation = MagicMock()- conversation.override_model_configs = None- mock_conversation_service.get_conversation.return_value = conversation-- app_model_config = MagicMock()- app_model_config.suggested_questions_after_answer_dict = {- "enabled": True,- "model": {"provider": "openai", "name": "invalid-model"},- }- mock_db.session.scalar.return_value = app_model_config-- mock_model_manager.return_value.get_model_instance.side_effect = ValueError("invalid model")- mock_memory.return_value.get_history_prompt_text.return_value = "histories"- mock_llm_gen.generate_suggested_questions_after_answer.return_value = ["Q1?"]-- result = MessageService.get_suggested_questions_after_answer(- app_model=app,- user=user,- message_id="msg-123",- invoke_from=MagicMock(),- session=mock_db.session,+ instruction_prompt=expected_prompt,+ model_config=expected_model,)- assert result == ["Q1?"]- mock_model_manager.return_value.get_default_model_instance.assert_called_once_with(- tenant_id="tenant-123",- model_type=ModelType.LLM,- )- mock_model_manager.return_value.get_model_instance.assert_not_called()-- @patch("services.message_service.db")- @patch("services.message_service.ModelManager.for_tenant")- @patch("services.message_service.TokenBufferMemory")- @patch("services.message_service.LLMGenerator")- @patch("services.message_service.TraceQueueManager")- @patch.object(MessageService, "get_message")- @patch("services.message_service.ConversationService")- def test_get_suggested_questions_chat_app_uses_compatible_override_model_config(+ def test_chat_app_uses_compatible_override_model_config(self,- mock_conversation_service: MagicMock,- mock_get_message: MagicMock,- mock_trace_manager: MagicMock,- mock_llm_gen: MagicMock,- mock_memory: MagicMock,- mock_model_manager: MagicMock,- mock_db: MagicMock,- factory: TestMessageServiceFactory,- ):- """Test legacy override configs are normalized before suggested questions reads them."""- app = factory.create_app_mock(mode=AppMode.CHAT)- app.tenant_id = "tenant-123"- user = factory.create_end_user_mock()- message = factory.create_message_mock()- mock_get_message.return_value = message-- conversation = MagicMock()- conversation.override_model_configs = json.dumps(- {- "speech_to_text": {"enabled": False},- "text_to_speech": {"enabled": False},- "retriever_resource": {"enabled": False},- "model": {"provider": "openai", "name": "gpt-4o-mini", "mode": "chat"},- "user_input_form": [],- "dataset_query_variable": "",- "pre_prompt": "",- "agent_mode": {- "enabled": False,- "max_iteration": 5,- "strategy": "function_call",- "tools": [],- },- "prompt_type": "simple",- "chat_prompt_config": {},- "completion_prompt_config": {},- "dataset_configs": {"retrieval_model": "single", "datasets": {"datasets": []}},- "file_upload": {- "image": {- "detail": "high",- "enabled": False,- "number_limits": 3,- "transfer_methods": ["remote_url", "local_file"],- }- },- "suggested_questions_after_answer": {- "enabled": True,- "prompt": "legacy prompt",- },- }- )- conversation.model_config = {- "opening_statement": None,- "suggested_questions": [],- "suggested_questions_after_answer": {- "enabled": True,- "prompt": "legacy prompt",- },- "speech_to_text": {"enabled": False},- "text_to_speech": {"enabled": False},- "retriever_resource": {"enabled": False},- "annotation_reply": {"enabled": False},- "more_like_this": {"enabled": False},- "sensitive_word_avoidance": {"enabled": False, "type": "", "config": {}},- "external_data_tools": [],+ monkeypatch: pytest.MonkeyPatch,+ factory: MessageServiceTestDataFactory,+ sqlite_session: Session,+ ) -> None:+ override = {"model": {"provider": "openai", "name": "gpt-4o-mini", "mode": "chat"},- "user_input_form": [],- "dataset_query_variable": "",- "pre_prompt": "",- "agent_mode": {"enabled": False, "strategy": "function_call", "tools": [], "prompt": None},- "prompt_type": "simple",- "chat_prompt_config": {},- "completion_prompt_config": {},- "dataset_configs": {"retrieval_model": "single", "datasets": {"datasets": []}},- "file_upload": {- "image": {- "detail": "high",- "enabled": False,- "number_limits": 3,- "transfer_methods": ["remote_url", "local_file"],- }- },- "model_id": None,- "provider": None,+ "suggested_questions_after_answer": {"enabled": True, "prompt": "legacy prompt"},}- conversation.model_config_with_session.return_value = conversation.model_config- mock_conversation_service.get_conversation.return_value = conversation-- mock_memory.return_value.get_history_prompt_text.return_value = "histories"- mock_llm_gen.generate_suggested_questions_after_answer.return_value = ["Q1?"]+ conversation = factory.create_conversation(override_model_configs=json.dumps(override))+ _, _, llm_generator = self._chat_boundaries(monkeypatch, conversation)result = MessageService.get_suggested_questions_after_answer(- app_model=app,- user=user,+ app_model=factory.create_app(mode=AppMode.CHAT),+ user=factory.create_end_user(),message_id="msg-123",- invoke_from=MagicMock(),- session=mock_db.session,+ invoke_from=InvokeFrom.WEB_APP,+ session=sqlite_session,)assert result == ["Q1?"]- mock_db.session.scalar.assert_not_called()- mock_llm_gen.generate_suggested_questions_after_answer.assert_called_once_with(+ llm_generator.generate_suggested_questions_after_answer.assert_called_once_with(tenant_id="tenant-123",histories="histories",instruction_prompt="legacy prompt",model_config=None,)- # Test 30: get_suggested_questions_after_answer - Disabled Error- @patch("services.message_service.WorkflowService")- @patch("services.message_service.AdvancedChatAppConfigManager")- @patch.object(MessageService, "get_message")- @patch("services.message_service.ConversationService")- def test_get_suggested_questions_disabled_error(+ def test_disabled_error(self,- mock_conversation_service,- mock_get_message,- mock_config_manager,- mock_workflow_service,- factory: TestMessageServiceFactory,- ):- """Test SuggestedQuestionsAfterAnswerDisabledError is raised when feature is disabled."""- # Arrange- app = factory.create_app_mock(mode=AppMode.ADVANCED_CHAT.value)- user = factory.create_end_user_mock()- mock_get_message.return_value = factory.create_message_mock()-+ monkeypatch: pytest.MonkeyPatch,+ factory: MessageServiceTestDataFactory,+ sqlite_session: Session,+ ) -> None:+ conversation = factory.create_conversation()+ self._chat_boundaries(monkeypatch, conversation)workflow = MagicMock()- mock_workflow_service.return_value.get_published_workflow.return_value = workflow-- app_config = MagicMock()- app_config.additional_features.suggested_questions_after_answer = False- mock_config_manager.get_app_config.return_value = app_config+ workflow_service = MagicMock()+ workflow_service.return_value.get_published_workflow.return_value = workflow+ monkeypatch.setattr(service_module, "WorkflowService", workflow_service)+ app_config_manager = MagicMock()+ app_config_manager.get_app_config.return_value.additional_features.suggested_questions_after_answer = False+ monkeypatch.setattr(service_module, "AdvancedChatAppConfigManager", app_config_manager)- # Act & Assertwith pytest.raises(SuggestedQuestionsAfterAnswerDisabledError):MessageService.get_suggested_questions_after_answer(- app_model=app,- user=user,+ app_model=factory.create_app(mode=AppMode.ADVANCED_CHAT),+ user=factory.create_end_user(),message_id="msg-123",- invoke_from=MagicMock(),- session=MagicMock(),+ invoke_from=InvokeFrom.WEB_APP,+ session=sqlite_session,)