from unittest.mock import patch import pytest from faker import Faker from sqlalchemy.orm import Session from models.enums import ConversationFromSource, FeedbackRating, InvokeFrom from models.model import MessageFeedback from services.app_service import AppService, CreateAppParams from services.errors.message import ( FirstMessageNotExistsError, LastMessageNotExistsError, MessageNotExistsError, SuggestedQuestionsAfterAnswerDisabledError, ) from services.message_service import MessageService from tests.test_containers_integration_tests.helpers import generate_valid_password class TestMessageService: """Integration tests for MessageService using testcontainers.""" @pytest.fixture def mock_external_service_dependencies(self): """Mock setup for external service dependencies.""" with ( patch("services.account_service.FeatureService") as mock_account_feature_service, patch("services.message_service.ModelManager.for_tenant") as mock_model_manager, patch("services.message_service.WorkflowService") as mock_workflow_service, patch("services.message_service.AdvancedChatAppConfigManager") as mock_app_config_manager, patch("services.message_service.LLMGenerator") as mock_llm_generator, patch("services.message_service.TraceQueueManager") as mock_trace_manager_class, patch("services.message_service.TokenBufferMemory") as mock_token_buffer_memory, ): # Setup default mock returns mock_account_feature_service.get_features.return_value.billing.enabled = False # Mock ModelManager mock_model_instance = mock_model_manager.return_value.get_default_model_instance.return_value mock_model_instance.get_tts_voices.return_value = [{"value": "test-voice"}] # Mock get_model_instance method as well mock_model_manager.return_value.get_model_instance.return_value = mock_model_instance # Mock WorkflowService mock_workflow = mock_workflow_service.return_value.get_published_workflow.return_value mock_workflow_service.return_value.get_draft_workflow.return_value = mock_workflow # Mock AdvancedChatAppConfigManager mock_app_config = mock_app_config_manager.get_app_config.return_value mock_app_config.additional_features.suggested_questions_after_answer = True # Mock LLMGenerator mock_llm_generator.generate_suggested_questions_after_answer.return_value = ["Question 1", "Question 2"] # Mock TraceQueueManager mock_trace_manager_instance = mock_trace_manager_class.return_value # Mock TokenBufferMemory mock_memory_instance = mock_token_buffer_memory.return_value mock_memory_instance.get_history_prompt_text.return_value = "Mocked history prompt" yield { "account_feature_service": mock_account_feature_service, "model_manager": mock_model_manager, "workflow_service": mock_workflow_service, "app_config_manager": mock_app_config_manager, "llm_generator": mock_llm_generator, "trace_manager_class": mock_trace_manager_class, "trace_manager_instance": mock_trace_manager_instance, "token_buffer_memory": mock_token_buffer_memory, # "current_user": mock_current_user, } def _create_test_app_and_account(self, db_session_with_containers: Session, mock_external_service_dependencies): """ Helper method to create a test app and account for testing. Args: db_session_with_containers: Database session from testcontainers infrastructure mock_external_service_dependencies: Mock dependencies Returns: tuple: (app, account) - Created app and account instances """ fake = Faker() # Setup mocks for account creation mock_external_service_dependencies[ "account_feature_service" ].get_system_features.return_value.is_allow_register = True # Create account and tenant first from services.account_service import AccountService, TenantService account = AccountService.create_account( email=fake.email(), name=fake.name(), interface_language="en-US", password=generate_valid_password(fake), ) TenantService.create_owner_tenant_if_not_exist(account, name=fake.company()) tenant = account.current_tenant # Setup app creation arguments app_args = CreateAppParams( name=fake.company(), description=fake.text(max_nb_chars=100), mode="advanced-chat", # Use advanced-chat mode to use mocked workflow, icon_type="emoji", icon="🤖", icon_background="#FF6B6B", api_rph=100, api_rpm=10, ) # Create app app_service = AppService() app = app_service.create_app(tenant.id, app_args, account) # Setup current_user mock self._mock_current_user(mock_external_service_dependencies, account.id, tenant.id) return app, account def _mock_current_user(self, mock_external_service_dependencies, account_id, tenant_id): """ Helper method to mock the current user for testing. """ # mock_external_service_dependencies["current_user"].id = account_id # mock_external_service_dependencies["current_user"].current_tenant_id = tenant_id def _create_test_conversation(self, db_session_with_containers: Session, app, account, fake): """ Helper method to create a test conversation with all required fields. """ from models.model import Conversation conversation = Conversation( app_id=app.id, app_model_config_id=None, model_provider=None, model_id="", override_model_configs=None, mode=app.mode, name=fake.sentence(), inputs={}, introduction="", system_instruction="", system_instruction_tokens=0, status="normal", invoke_from=InvokeFrom.EXPLORE, from_source=ConversationFromSource.CONSOLE, from_end_user_id=None, from_account_id=account.id, ) db_session_with_containers.add(conversation) db_session_with_containers.flush() return conversation def _create_test_message(self, db_session_with_containers: Session, app, conversation, account, fake): """ Helper method to create a test message with all required fields. """ import json from models.model import Message message = Message( app_id=app.id, model_provider=None, model_id="", override_model_configs=None, conversation_id=conversation.id, inputs={}, query=fake.sentence(), message=json.dumps([{"role": "user", "text": fake.sentence()}]), message_tokens=0, message_unit_price=0, message_price_unit=0.001, answer=fake.text(max_nb_chars=200), answer_tokens=0, answer_unit_price=0, answer_price_unit=0.001, parent_message_id=None, provider_response_latency=0, total_price=0, currency="USD", invoke_from=InvokeFrom.EXPLORE, from_source=ConversationFromSource.CONSOLE, from_end_user_id=None, from_account_id=account.id, ) db_session_with_containers.add(message) db_session_with_containers.commit() return message def test_pagination_by_first_id_success( self, db_session_with_containers: Session, mock_external_service_dependencies ): """ Test successful pagination by first ID. """ fake = Faker() app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies) # Create a conversation and multiple messages conversation = self._create_test_conversation(db_session_with_containers, app, account, fake) messages = [] for i in range(5): message = self._create_test_message(db_session_with_containers, app, conversation, account, fake) messages.append(message) # Test pagination by first ID result = MessageService.pagination_by_first_id( app_model=app, user=account, conversation_id=conversation.id, first_id=messages[2].id, # Use middle message as first_id limit=2, order="asc", ) # Verify results assert result.limit == 2 assert len(result.data) == 2 # total 5, from the middle, no more assert result.has_more is False # Verify messages are in ascending order assert result.data[0].created_at <= result.data[1].created_at def test_pagination_by_first_id_no_user( self, db_session_with_containers: Session, mock_external_service_dependencies ): """ Test pagination by first ID when no user is provided. """ fake = Faker() app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies) # Test pagination with no user result = MessageService.pagination_by_first_id( app_model=app, user=None, conversation_id=fake.uuid4(), first_id=None, limit=10 ) # Verify empty result assert result.limit == 10 assert len(result.data) == 0 assert result.has_more is False def test_pagination_by_first_id_no_conversation_id( self, db_session_with_containers: Session, mock_external_service_dependencies ): """ Test pagination by first ID when no conversation ID is provided. """ fake = Faker() app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies) # Test pagination with no conversation ID result = MessageService.pagination_by_first_id( app_model=app, user=account, conversation_id="", first_id=None, limit=10 ) # Verify empty result assert result.limit == 10 assert len(result.data) == 0 assert result.has_more is False def test_pagination_by_first_id_invalid_first_id( self, db_session_with_containers: Session, mock_external_service_dependencies ): """ Test pagination by first ID with invalid first_id. """ fake = Faker() app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies) # Create a conversation and message conversation = self._create_test_conversation(db_session_with_containers, app, account, fake) self._create_test_message(db_session_with_containers, app, conversation, account, fake) # Test pagination with invalid first_id with pytest.raises(FirstMessageNotExistsError): MessageService.pagination_by_first_id( app_model=app, user=account, conversation_id=conversation.id, first_id=fake.uuid4(), # Non-existent message ID limit=10, ) def test_pagination_by_last_id_success( self, db_session_with_containers: Session, mock_external_service_dependencies ): """ Test successful pagination by last ID. """ fake = Faker() app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies) # Create a conversation and multiple messages conversation = self._create_test_conversation(db_session_with_containers, app, account, fake) messages = [] for i in range(5): message = self._create_test_message(db_session_with_containers, app, conversation, account, fake) messages.append(message) # Test pagination by last ID result = MessageService.pagination_by_last_id( app_model=app, user=account, last_id=messages[2].id, # Use middle message as last_id limit=2, conversation_id=conversation.id, ) # Verify results assert result.limit == 2 assert len(result.data) == 2 # total 5, from the middle, no more assert result.has_more is False # Verify messages are in descending order assert result.data[0].created_at >= result.data[1].created_at def test_pagination_by_last_id_with_include_ids( self, db_session_with_containers: Session, mock_external_service_dependencies ): """ Test pagination by last ID with include_ids filter. """ fake = Faker() app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies) # Create a conversation and multiple messages conversation = self._create_test_conversation(db_session_with_containers, app, account, fake) messages = [] for i in range(5): message = self._create_test_message(db_session_with_containers, app, conversation, account, fake) messages.append(message) # Test pagination with include_ids include_ids = [messages[0].id, messages[1].id, messages[2].id] result = MessageService.pagination_by_last_id( app_model=app, user=account, last_id=messages[1].id, limit=2, include_ids=include_ids ) # Verify results assert result.limit == 2 assert len(result.data) <= 2 # Verify all returned messages are in include_ids for message in result.data: assert message.id in include_ids def test_pagination_by_last_id_no_user( self, db_session_with_containers: Session, mock_external_service_dependencies ): """ Test pagination by last ID when no user is provided. """ fake = Faker() app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies) # Test pagination with no user result = MessageService.pagination_by_last_id(app_model=app, user=None, last_id=None, limit=10) # Verify empty result assert result.limit == 10 assert len(result.data) == 0 assert result.has_more is False def test_pagination_by_last_id_invalid_last_id( self, db_session_with_containers: Session, mock_external_service_dependencies ): """ Test pagination by last ID with invalid last_id. """ fake = Faker() app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies) # Create a conversation and message conversation = self._create_test_conversation(db_session_with_containers, app, account, fake) self._create_test_message(db_session_with_containers, app, conversation, account, fake) # Test pagination with invalid last_id with pytest.raises(LastMessageNotExistsError): MessageService.pagination_by_last_id( app_model=app, user=account, last_id=fake.uuid4(), # Non-existent message ID limit=10, conversation_id=conversation.id, ) def test_create_feedback_success(self, db_session_with_containers: Session, mock_external_service_dependencies): """ Test successful creation of feedback. """ fake = Faker() app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies) # Create a conversation and message conversation = self._create_test_conversation(db_session_with_containers, app, account, fake) message = self._create_test_message(db_session_with_containers, app, conversation, account, fake) # Create feedback rating = FeedbackRating.LIKE content = fake.text(max_nb_chars=100) feedback = MessageService.create_feedback( app_model=app, message_id=message.id, user=account, rating=rating, content=content ) # Verify feedback was created correctly assert feedback.app_id == app.id assert feedback.conversation_id == conversation.id assert feedback.message_id == message.id assert feedback.rating == rating assert feedback.content == content assert feedback.from_source == "admin" assert feedback.from_account_id == account.id assert feedback.from_end_user_id is None def test_create_feedback_no_user(self, db_session_with_containers: Session, mock_external_service_dependencies): """ Test creating feedback when no user is provided. """ fake = Faker() app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies) # Create a conversation and message conversation = self._create_test_conversation(db_session_with_containers, app, account, fake) message = self._create_test_message(db_session_with_containers, app, conversation, account, fake) # Test creating feedback with no user with pytest.raises(ValueError, match="user cannot be None"): MessageService.create_feedback( app_model=app, message_id=message.id, user=None, rating=FeedbackRating.LIKE, content=fake.text(max_nb_chars=100), ) def test_create_feedback_update_existing( self, db_session_with_containers: Session, mock_external_service_dependencies ): """ Test updating existing feedback. """ fake = Faker() app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies) # Create a conversation and message conversation = self._create_test_conversation(db_session_with_containers, app, account, fake) message = self._create_test_message(db_session_with_containers, app, conversation, account, fake) # Create initial feedback initial_rating = FeedbackRating.LIKE initial_content = fake.text(max_nb_chars=100) feedback = MessageService.create_feedback( app_model=app, message_id=message.id, user=account, rating=initial_rating, content=initial_content ) # Update feedback updated_rating = FeedbackRating.DISLIKE updated_content = fake.text(max_nb_chars=100) updated_feedback = MessageService.create_feedback( app_model=app, message_id=message.id, user=account, rating=updated_rating, content=updated_content ) # Verify feedback was updated correctly assert updated_feedback.id == feedback.id assert updated_feedback.rating == updated_rating assert updated_feedback.content == updated_content assert updated_feedback.rating != initial_rating assert updated_feedback.content != initial_content def test_create_feedback_delete_existing( self, db_session_with_containers: Session, mock_external_service_dependencies ): """ Test deleting existing feedback by setting rating to None. """ fake = Faker() app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies) # Create a conversation and message conversation = self._create_test_conversation(db_session_with_containers, app, account, fake) message = self._create_test_message(db_session_with_containers, app, conversation, account, fake) # Create initial feedback feedback = MessageService.create_feedback( app_model=app, message_id=message.id, user=account, rating=FeedbackRating.LIKE, content=fake.text(max_nb_chars=100), ) # Delete feedback by setting rating to None MessageService.create_feedback(app_model=app, message_id=message.id, user=account, rating=None, content=None) # Verify feedback was deleted deleted_feedback = ( db_session_with_containers.query(MessageFeedback).where(MessageFeedback.id == feedback.id).first() ) assert deleted_feedback is None def test_create_feedback_no_rating_when_not_exists( self, db_session_with_containers: Session, mock_external_service_dependencies ): """ Test creating feedback with no rating when feedback doesn't exist. """ fake = Faker() app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies) # Create a conversation and message conversation = self._create_test_conversation(db_session_with_containers, app, account, fake) message = self._create_test_message(db_session_with_containers, app, conversation, account, fake) # Test creating feedback with no rating when no feedback exists with pytest.raises(ValueError, match="rating cannot be None when feedback not exists"): MessageService.create_feedback( app_model=app, message_id=message.id, user=account, rating=None, content=None ) def test_get_all_messages_feedbacks_success( self, db_session_with_containers: Session, mock_external_service_dependencies ): """ Test successful retrieval of all message feedbacks. """ fake = Faker() app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies) # Create multiple conversations and messages with feedbacks feedbacks = [] for i in range(3): conversation = self._create_test_conversation(db_session_with_containers, app, account, fake) message = self._create_test_message(db_session_with_containers, app, conversation, account, fake) feedback = MessageService.create_feedback( app_model=app, message_id=message.id, user=account, rating=FeedbackRating.LIKE if i % 2 == 0 else FeedbackRating.DISLIKE, content=f"Feedback {i}: {fake.text(max_nb_chars=50)}", ) feedbacks.append(feedback) # Get all feedbacks result = MessageService.get_all_messages_feedbacks(app, page=1, limit=10) # Verify results assert len(result) == 3 # Verify feedbacks are ordered by created_at desc for i in range(len(result) - 1): assert result[i]["created_at"] >= result[i + 1]["created_at"] def test_get_all_messages_feedbacks_pagination( self, db_session_with_containers: Session, mock_external_service_dependencies ): """ Test pagination of message feedbacks. """ fake = Faker() app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies) # Create multiple conversations and messages with feedbacks for i in range(5): conversation = self._create_test_conversation(db_session_with_containers, app, account, fake) message = self._create_test_message(db_session_with_containers, app, conversation, account, fake) MessageService.create_feedback( app_model=app, message_id=message.id, user=account, rating=FeedbackRating.LIKE, content=f"Feedback {i}", ) # Get feedbacks with pagination result_page_1 = MessageService.get_all_messages_feedbacks(app, page=1, limit=3) result_page_2 = MessageService.get_all_messages_feedbacks(app, page=2, limit=3) # Verify pagination results assert len(result_page_1) == 3 assert len(result_page_2) == 2 # Verify no overlap between pages page_1_ids = {feedback["id"] for feedback in result_page_1} page_2_ids = {feedback["id"] for feedback in result_page_2} assert len(page_1_ids.intersection(page_2_ids)) == 0 def test_get_message_success(self, db_session_with_containers: Session, mock_external_service_dependencies): """ Test successful retrieval of message. """ fake = Faker() app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies) # Create a conversation and message conversation = self._create_test_conversation(db_session_with_containers, app, account, fake) message = self._create_test_message(db_session_with_containers, app, conversation, account, fake) # Get message retrieved_message = MessageService.get_message(app_model=app, user=account, message_id=message.id) # Verify message was retrieved correctly assert retrieved_message.id == message.id assert retrieved_message.app_id == app.id assert retrieved_message.conversation_id == conversation.id assert retrieved_message.from_source == "console" assert retrieved_message.from_account_id == account.id def test_get_message_not_exists(self, db_session_with_containers: Session, mock_external_service_dependencies): """ Test getting message that doesn't exist. """ fake = Faker() app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies) # Test getting non-existent message with pytest.raises(MessageNotExistsError): MessageService.get_message(app_model=app, user=account, message_id=fake.uuid4()) def test_get_message_wrong_user(self, db_session_with_containers: Session, mock_external_service_dependencies): """ Test getting message with wrong user (different account). """ fake = Faker() app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies) # Create a conversation and message conversation = self._create_test_conversation(db_session_with_containers, app, account, fake) message = self._create_test_message(db_session_with_containers, app, conversation, account, fake) # Create another account from services.account_service import AccountService, TenantService other_account = AccountService.create_account( email=fake.email(), name=fake.name(), interface_language="en-US", password=generate_valid_password(fake), ) TenantService.create_owner_tenant_if_not_exist(other_account, name=fake.company()) # Test getting message with different user with pytest.raises(MessageNotExistsError): MessageService.get_message(app_model=app, user=other_account, message_id=message.id) def test_get_suggested_questions_after_answer_success( self, db_session_with_containers: Session, mock_external_service_dependencies ): """ Test successful generation of suggested questions after answer. """ fake = Faker() app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies) # Create a conversation and message conversation = self._create_test_conversation(db_session_with_containers, app, account, fake) message = self._create_test_message(db_session_with_containers, app, conversation, account, fake) # Mock the LLMGenerator to return specific questions mock_questions = ["What is AI?", "How does machine learning work?", "Tell me about neural networks"] mock_external_service_dependencies[ "llm_generator" ].generate_suggested_questions_after_answer.return_value = mock_questions # Get suggested questions from core.app.entities.app_invoke_entities import InvokeFrom result = MessageService.get_suggested_questions_after_answer( app_model=app, user=account, message_id=message.id, invoke_from=InvokeFrom.SERVICE_API ) # Verify results assert result == mock_questions # Verify LLMGenerator was called mock_external_service_dependencies[ "llm_generator" ].generate_suggested_questions_after_answer.assert_called_once() # Verify TraceQueueManager was called mock_external_service_dependencies["trace_manager_instance"].add_trace_task.assert_called_once() def test_get_suggested_questions_after_answer_no_user( self, db_session_with_containers: Session, mock_external_service_dependencies ): """ Test getting suggested questions when no user is provided. """ fake = Faker() app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies) # Create a conversation and message conversation = self._create_test_conversation(db_session_with_containers, app, account, fake) message = self._create_test_message(db_session_with_containers, app, conversation, account, fake) # Test getting suggested questions with no user from core.app.entities.app_invoke_entities import InvokeFrom with pytest.raises(ValueError, match="user cannot be None"): MessageService.get_suggested_questions_after_answer( app_model=app, user=None, message_id=message.id, invoke_from=InvokeFrom.SERVICE_API ) def test_get_suggested_questions_after_answer_disabled( self, db_session_with_containers: Session, mock_external_service_dependencies ): """ Test getting suggested questions when feature is disabled. """ fake = Faker() app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies) # Create a conversation and message conversation = self._create_test_conversation(db_session_with_containers, app, account, fake) message = self._create_test_message(db_session_with_containers, app, conversation, account, fake) # Mock the feature to be disabled mock_external_service_dependencies[ "app_config_manager" ].get_app_config.return_value.additional_features.suggested_questions_after_answer = False # Test getting suggested questions when feature is disabled from core.app.entities.app_invoke_entities import InvokeFrom with pytest.raises(SuggestedQuestionsAfterAnswerDisabledError): MessageService.get_suggested_questions_after_answer( app_model=app, user=account, message_id=message.id, invoke_from=InvokeFrom.SERVICE_API ) def test_get_suggested_questions_after_answer_no_workflow( self, db_session_with_containers: Session, mock_external_service_dependencies ): """ Test getting suggested questions when no workflow exists. """ fake = Faker() app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies) # Create a conversation and message conversation = self._create_test_conversation(db_session_with_containers, app, account, fake) message = self._create_test_message(db_session_with_containers, app, conversation, account, fake) # Mock no workflow mock_external_service_dependencies["workflow_service"].return_value.get_published_workflow.return_value = None # Get suggested questions (should return empty list) from core.app.entities.app_invoke_entities import InvokeFrom result = MessageService.get_suggested_questions_after_answer( app_model=app, user=account, message_id=message.id, invoke_from=InvokeFrom.SERVICE_API ) # Verify empty result assert result == [] def test_get_suggested_questions_after_answer_debugger_mode( self, db_session_with_containers: Session, mock_external_service_dependencies ): """ Test getting suggested questions in debugger mode. """ fake = Faker() app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies) # Create a conversation and message conversation = self._create_test_conversation(db_session_with_containers, app, account, fake) message = self._create_test_message(db_session_with_containers, app, conversation, account, fake) # Mock questions mock_questions = ["Debug question 1", "Debug question 2"] mock_external_service_dependencies[ "llm_generator" ].generate_suggested_questions_after_answer.return_value = mock_questions # Get suggested questions in debugger mode from core.app.entities.app_invoke_entities import InvokeFrom result = MessageService.get_suggested_questions_after_answer( app_model=app, user=account, message_id=message.id, invoke_from=InvokeFrom.DEBUGGER ) # Verify results assert result == mock_questions # Verify draft workflow was used instead of published workflow mock_external_service_dependencies["workflow_service"].return_value.get_draft_workflow.assert_called_once_with( app_model=app ) # Verify TraceQueueManager was called mock_external_service_dependencies["trace_manager_instance"].add_trace_task.assert_called_once()