iatoolkit 0.8.1__py3-none-any.whl → 0.63.4__py3-none-any.whl

tests/services/test_query_service.py

@@ -1,243 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-
-import pytest
-from unittest.mock import MagicMock, patch
-import os
-import base64
-import json
-
-from iatoolkit.services.query_service import QueryService
-from iatoolkit.services.prompt_manager_service import PromptService
-from iatoolkit.services.user_session_context_service import UserSessionContextService
-from iatoolkit.repositories.profile_repo import ProfileRepo
-from iatoolkit.repositories.models import User, Company
-from iatoolkit.common.util import Utility
-from iatoolkit.infra.llm_client import llmClient
-from iatoolkit.common.exceptions import IAToolkitException
-
-
-class TestQueryService:
-    """
-    Test suite for the QueryService.
-    It uses a consistent setup to mock all dependencies and the global `current_iatoolkit` context.
-    """
-
-    @pytest.fixture(autouse=True)
-    def setup(self):
-        """
-        Set up a consistent, mocked environment for each test.
-        This includes mocking all dependencies and the global `current_iatoolkit` context.
-        """
-        # Mocks for all injected dependencies
-        self.document_service = MagicMock()
-        self.llmquery_repo = MagicMock()
-        self.profile_repo = MagicMock(spec=ProfileRepo)
-        self.prompt_service = MagicMock(spec=PromptService)
-        self.utility = MagicMock(spec=Utility)
-        self.llm_client_mock = MagicMock(spec=llmClient)
-        self.dispatcher = MagicMock()
-        self.session_context = MagicMock(spec=UserSessionContextService)
-
-
-        # --- Common mock configurations ---
-        self.utility.resolve_user_identifier.side_effect = lambda external_user_id=None,local_user_id=0: (external_user_id, False) or (f"User_{local_user_id}", True)
-
-        self.user = User(id=1, email='test@user.com')
-        self.company = Company(id=100, name='Test Company', short_name='test_company')
-        self.profile_repo.get_company_by_short_name.return_value = self.company
-
-        # Default mock session data
-        self.session_context.get_last_response_id.return_value = 'prev_response_id'
-        self.session_context.get_user_session_data.return_value = {'user_role': 'leader', 'user_name': 'session_user'}
-
-        # Default mock LLM response
-        self.mock_llm_response = {"valid_response": True, "answer": "LLM test response",
-                                  "response_id": "new_llm_response_id"}
-        self.llm_client_mock.invoke.return_value = self.mock_llm_response
-        self.llm_client_mock.set_company_context.return_value = 'new_context_response_id'
-
-        # Default mock Dispatcher responses
-        self.dispatcher.get_user_info.return_value = {'user_role': 'leader', 'user_name': 'test_user'}
-        self.dispatcher.get_company_services.return_value = [{'name': 'service1'}]
-        self.dispatcher.get_company_context.return_value = "Specific company context."
-
-        # Default prompt rendering
-        self.prompt_service.get_system_prompt.return_value = "System prompt template: {{ user_role }}"
-        self.utility.render_prompt_from_string.return_value = "Rendered system prompt: leader"
-
-        # Default model type
-        self.utility.is_openai_model.return_value = True
-        self.utility.is_gemini_model.return_value = False
-
-        # Create the service instance under test. This now works because the context is patched.
-        with patch.dict(os.environ, {"LLM_MODEL": "gpt-test"}):
-            self.service = QueryService(
-                llm_client=self.llm_client_mock,
-                document_service=self.document_service,
-                document_repo=MagicMock(),
-                llmquery_repo=self.llmquery_repo,
-                profile_repo=self.profile_repo,
-                prompt_service=self.prompt_service,
-                util=self.utility,
-                dispatcher=self.dispatcher,
-                session_context=self.session_context
-            )
-
-        # File content for file loading tests
-        self.document_content = b'document content'
-        self.base64_content = base64.b64encode(self.document_content)
-
-        yield  # The test runs at this point
-
-    # --- Input Validation Tests ---
-
-    def test_llm_query_fails_if_no_company(self):
-        """Tests that the query fails if the company does not exist."""
-        self.profile_repo.get_company_by_short_name.return_value = None
-        result = self.service.llm_query(company_short_name='a_company', question="test", external_user_id="test_user")
-        assert "No existe Company ID" in result["error_message"]
-
-    def test_llm_query_fails_if_no_question_or_prompt(self):
-        """Tests that the query fails if both question and prompt_name are missing."""
-        result = self.service.llm_query(company_short_name='a_company', external_user_id="test_user")
-        assert "Hola, cual es tu pregunta?" in result["error_message"]
-
-    def test_llm_query_fails_if_no_previous_response_id_for_openai(self):
-        """Tests query failure if no previous response ID is found for OpenAI models."""
-        self.session_context.get_last_response_id.return_value = None
-        self.llm_client_mock.set_company_context.return_value = None  # Simulate that context initialization also fails
-        self.utility.is_openai_model.return_value = True
-
-        result = self.service.llm_query(
-            company_short_name='a_company',
-            external_user_id="test_user",
-            question="test"
-        )
-        assert "FATAL: No se encontró 'previous_response_id'" in result["error_message"]
-
-    # --- Core Logic Tests ---
-
-    def test_llm_query_with_direct_question_successfully(self):
-        """Tests a direct query and the correct management of response IDs in the session."""
-        self.utility.is_openai_model.return_value = True
-
-        result = self.service.llm_query(company_short_name='test_company', question='hello',
-                                        external_user_id='test_user')
-
-        self.llm_client_mock.invoke.assert_called_once()
-        call_args = self.llm_client_mock.invoke.call_args.kwargs
-        assert call_args['company'] == self.company
-        assert call_args['user_identifier'] == 'test_user'
-        assert call_args['previous_response_id'] == 'prev_response_id'
-        assert "La pregunta que debes responder es: hello" in call_args['context']
-
-        self.session_context.save_last_response_id.assert_called_once_with(
-            'test_company', 'test_user', 'new_llm_response_id'
-        )
-        assert result['answer'] == 'LLM test response'
-
-    def test_llm_query_with_prompt_name_merges_data_correctly(self):
-        """Tests that session data is merged with request data, with the latter taking priority."""
-        request_client_data = {'user_name': 'request_user'}
-        external_user_id = 'ext_user_2'
-
-        self.service.llm_query(
-            company_short_name='a_company',
-            external_user_id=external_user_id,
-            prompt_name="analisis_cartera",
-            client_data=request_client_data
-        )
-
-        self.llm_client_mock.invoke.assert_called_once()
-        call_kwargs = self.llm_client_mock.invoke.call_args.kwargs
-
-        expected_data = {
-            'prompt': 'analisis_cartera',
-            'data': {
-                'user_role': 'leader',  # From session
-                'user_name': 'request_user',  # From request (overwrites session)
-                'user_id': external_user_id  # Added by the service
-            }
-        }
-
-        actual_question_dict = json.loads(call_kwargs['question'])
-        assert actual_question_dict == expected_data
-
-    # --- Context Initialization Tests ---
-
-    def test_llm_init_context_happy_path_external_user(self):
-        """Tests the successful, full context initialization flow for an external user."""
-        self.utility.is_openai_model.return_value = True
-
-        self.service.llm_init_context(
-            company_short_name='test_co',
-            external_user_id='ext_user_123'
-        )
-
-        self.session_context.clear_all_context.assert_called_once_with(
-            company_short_name='test_co', user_identifier='ext_user_123'
-        )
-        self.session_context.save_user_session_data.assert_called_once_with(
-            'test_co', 'ext_user_123', self.dispatcher.get_user_info.return_value
-        )
-        self.llm_client_mock.set_company_context.assert_called_once()
-        self.session_context.save_last_response_id.assert_called_once_with(
-            'test_co', 'ext_user_123', 'new_context_response_id'
-        )
-
-    def test_llm_init_context_for_gemini_model(self):
-        """Tests that for Gemini models, context is not sent to the LLM, but a flag is returned."""
-        self.utility.is_openai_model.return_value = False
-        self.utility.is_gemini_model.return_value = True
-
-        response = self.service.llm_init_context(
-            company_short_name='test_co',
-            external_user_id='ext_user_123',
-            model="gemini"
-        )
-
-        self.llm_client_mock.set_company_context.assert_not_called()
-        self.session_context.save_context_history.assert_called_once()
-        assert response == "gemini-context-initialized"
-
-    def test_llm_init_context_raises_exception_if_company_not_found(self):
-        """Tests that an exception is raised if the company does not exist during context init."""
-        self.profile_repo.get_company_by_short_name.return_value = None
-        with pytest.raises(IAToolkitException, match="Empresa no encontrada: invalid_co"):
-            self.service.llm_init_context(company_short_name='invalid_co', external_user_id='user1')
-
-    # --- File Loading Tests ---
-
-    @patch('os.path.exists', return_value=False)
-    def test_load_files_for_context_handles_nonexistent_file(self, mock_exists):
-        """Tests that a non-existent file is handled gracefully."""
-        result = self.service.load_files_for_context([{'file_id': 'nonexistent.txt'}])
-        assert "no fue encontrado y no pudo ser cargado" in result
-
-    @patch('os.path.exists', return_value=True)
-    def test_load_files_for_context_handles_service_exception(self, mock_exists):
-        """Tests that exceptions from the document service are caught."""
-        self.document_service.file_to_txt.side_effect = Exception("Service failed")
-        files = [{'file_id': 'file.pdf', 'base64': self.base64_content.decode('utf-8')}]
-        result = self.service.load_files_for_context(files)
-        assert "Error al procesar el archivo file.pdf" in result
-
-    @patch('os.path.exists', return_value=True)
-    def test_load_files_for_context_builds_correctly(self, mock_exists):
-        """Tests that file context is built correctly from base64 content."""
-        self.document_service.file_to_txt.return_value = "Text from file"
-        files = [{'file_id': 'test.pdf', 'base64': self.base64_content.decode('utf-8')}]
-        result = self.service.load_files_for_context(files)
-
-        self.document_service.file_to_txt.assert_called_once_with('test.pdf', self.document_content)
-        expected_context = """
-            A continuación encontraras una lista de documentos adjuntos
-            enviados por el usuario que hace la pregunta, 
-            en total son: 1 documentos adjuntos
-            
-<document name='test.pdf'>
-Text from file
-</document>
-"""
-        assert result == expected_context

tests/services/test_search_service.py

@@ -1,39 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-from unittest.mock import MagicMock
-from iatoolkit.services.search_service import SearchService
-from iatoolkit.repositories.models import Document
-
-
-class TestSearchService:
-    def setup_method(self):
-        # Mock de dependencias
-        self.doc_repo = MagicMock()
-        self.vs_repo = MagicMock()
-
-        self.service = SearchService(
-            doc_repo=self.doc_repo,
-            vs_repo=self.vs_repo
-        )
-
-
-    def test_search_documents_no_results(self):
-        self.vs_repo.query.return_value = []
-
-        result = self.service.search(company_id=1, query="consulta_inexistente")
-        assert result == ''
-
-
-    def test_search_documents_success(self):
-        # Mock de chunks devueltos por el vector store
-        document = Document(id=1, company_id=1, filename='doc1.pdf', content="Contenido del documento")
-        self.vs_repo.query.return_value = [document]
-
-
-        # Llamar a search y verificar resultado
-        result = self.service.search(company_id=1, query="consulta")
-
-        assert result == 'documento "doc1.pdf": Contenido del documento\n'

tests/services/test_sql_service.py

@@ -1,160 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import pytest
-from unittest.mock import MagicMock
-from sqlalchemy import text # Para verificar el argumento de text()
-import json
-from datetime import datetime
-from iatoolkit.services.sql_service import SqlService
-from iatoolkit.repositories.database_manager import DatabaseManager
-from iatoolkit.common.util import Utility
-from iatoolkit.common.exceptions import IAToolkitException
-
-class TestSqlService:
-    def setup_method(self):
-
-        self.db_manager_mock = MagicMock(spec=DatabaseManager)
-        self.util_mock = MagicMock(spec=Utility)
-
-        # Mock para la sesión de base de datos y el objeto de resultado de la consulta
-        self.session_mock = MagicMock()
-        self.mock_result_proxy = MagicMock() # Simula el objeto ResultProxy de SQLAlchemy
-
-        # Configurar los mocks para que devuelvan otros mocks cuando sea necesario
-        self.db_manager_mock.get_session.return_value = self.session_mock
-        self.session_mock.execute.return_value = self.mock_result_proxy
-
-        # Instanciar el servicio con las dependencias mockeadas
-        self.service = SqlService(util=self.util_mock)
-
-    def test_exec_sql_success_with_simple_data(self):
-        """
-        Prueba la ejecución exitosa de una consulta SQL que devuelve datos simples (int, str).
-        En este caso, la función de serialización personalizada no debería ser invocada para estos tipos.
-        """
-        sql_statement = "SELECT id, name FROM users WHERE status = 'active'"
-        expected_keys = ['id', 'name']
-        # Datos que json.dumps puede manejar directamente
-        expected_rows_from_db = [(1, 'Alice'), (2, 'Bob')]
-        # Cómo se verán los datos después del procesamiento interno en exec_sql antes de json.dumps
-        expected_rows_as_dicts = [{'id': 1, 'name': 'Alice'}, {'id': 2, 'name': 'Bob'}]
-
-        self.mock_result_proxy.keys.return_value = expected_keys
-        self.mock_result_proxy.fetchall.return_value = expected_rows_from_db
-
-        # Ejecutar el método a probar
-        result_json = self.service.exec_sql(self.db_manager_mock, sql_statement)
-
-        # Verificar que la sesión y la ejecución fueron llamadas correctamente
-        self.db_manager_mock.get_session.assert_called_once()
-        self.session_mock.execute.assert_called_once()
-        # Verificar que el argumento de execute fue el objeto text(sql_statement)
-        args, _ = self.session_mock.execute.call_args
-        assert isinstance(args[0], type(text(""))) # Comprueba el tipo del argumento
-        assert str(args[0]) == sql_statement # Comprueba el contenido del SQL
-
-        self.mock_result_proxy.keys.assert_called_once()
-        self.mock_result_proxy.fetchall.assert_called_once()
-
-        # Verificar que la función de serialización personalizada no fue llamada
-        # para tipos que json.dumps maneja nativamente.
-        self.util_mock.serialize.assert_not_called()
-
-        # Verificar el resultado JSON
-        expected_json_output = json.dumps(expected_rows_as_dicts)
-        assert result_json == expected_json_output
-
-    def test_exec_sql_success_with_custom_data_type_serialization(self):
-        """
-        Prueba la ejecución exitosa de una consulta SQL que devuelve datos que requieren
-        serialización personalizada (ej. un objeto datetime).
-        """
-        sql_statement = "SELECT event_name, event_time FROM important_events"
-        original_datetime_obj = datetime(2024, 1, 15, 10, 30, 0)
-        # Suponemos que util.serialize convierte datetime a una string ISO
-        serialized_datetime_str = original_datetime_obj.isoformat()
-
-        expected_keys = ['event_name', 'event_time']
-        # La base de datos devuelve una tupla con un objeto datetime
-        expected_rows_from_db = [('Team Meeting', original_datetime_obj)]
-        # El diccionario que se pasará a json.dumps, después de que serialize haga su trabajo
-        expected_rows_as_dicts_after_serialization = [{'event_name': 'Team Meeting', 'event_time': serialized_datetime_str}]
-
-
-        self.mock_result_proxy.keys.return_value = expected_keys
-        self.mock_result_proxy.fetchall.return_value = expected_rows_from_db
-
-        # Configurar el mock de util.serialize para que maneje datetime
-        def mock_serializer(obj):
-            if isinstance(obj, datetime):
-                return obj.isoformat()
-            # Para cualquier otro tipo, podría devolverlo tal cual si json.dumps lo maneja,
-            # o lanzar un TypeError como lo haría json.dumps si default no estuviera.
-            return obj
-        self.util_mock.serialize.side_effect = mock_serializer
-
-        # Ejecutar el método a probar
-        result_json = self.service.exec_sql(self.db_manager_mock, sql_statement)
-
-        # Verificar llamadas
-        self.session_mock.execute.assert_called_once()
-        self.mock_result_proxy.keys.assert_called_once()
-        self.mock_result_proxy.fetchall.assert_called_once()
-
-        # Verificar que util.serialize fue llamado para el objeto datetime
-        self.util_mock.serialize.assert_called_once_with(original_datetime_obj)
-
-        # Verificar el resultado JSON
-        expected_json_output = json.dumps(expected_rows_as_dicts_after_serialization)
-        assert result_json == expected_json_output
-
-    def test_exec_sql_success_no_results(self):
-        """
-        Prueba la ejecución de una consulta SQL que no devuelve resultados.
-        """
-        sql_statement = "SELECT id FROM users WHERE name = 'NonExistentUser'"
-        expected_keys = ['id'] # Las claves se devuelven incluso sin filas
-        expected_rows_from_db = []
-        expected_rows_as_dicts = []
-
-        self.mock_result_proxy.keys.return_value = expected_keys
-        self.mock_result_proxy.fetchall.return_value = expected_rows_from_db
-
-        result_json = self.service.exec_sql(self.db_manager_mock, sql_statement)
-
-        self.session_mock.execute.assert_called_once()
-        self.mock_result_proxy.keys.assert_called_once()
-        self.mock_result_proxy.fetchall.assert_called_once()
-        self.util_mock.serialize.assert_not_called() # No hay datos que necesiten serialización
-
-        expected_json_output = json.dumps(expected_rows_as_dicts, indent=2)
-        assert result_json == expected_json_output
-
-    def test_exec_sql_raises_app_exception_on_database_error(self):
-        """
-        Prueba que se lanza una IAToolkitException cuando ocurre un error en la base de datos.
-        """
-        sql_statement = "SELECT * FROM table_that_does_not_exist"
-        original_db_error_message = "Error: Table not found"
-        # Configurar el mock para que lance una excepción cuando se llame a execute
-        self.session_mock.execute.side_effect = Exception(original_db_error_message)
-
-        with pytest.raises(IAToolkitException) as exc_info:
-            self.service.exec_sql(self.db_manager_mock, sql_statement)
-
-        # Verificar el tipo de excepción y el mensaje
-        assert exc_info.value.error_type == IAToolkitException.ErrorType.DATABASE_ERROR
-        assert original_db_error_message in str(exc_info.value)
-        # Verificar que la excepción original está encadenada (from e)
-        assert isinstance(exc_info.value.__cause__, Exception)
-        assert str(exc_info.value.__cause__) == original_db_error_message
-
-        # Verificar que se intentó ejecutar la consulta
-        self.session_mock.execute.assert_called_once()
-        # Otros mocks no deberían haber sido llamados si execute falló
-        self.mock_result_proxy.keys.assert_not_called()
-        self.mock_result_proxy.fetchall.assert_not_called()
-        self.util_mock.serialize.assert_not_called()