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

tests/services/test_excel_service.py

@@ -1,208 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import os
-import shutil
-import tempfile
-from unittest.mock import MagicMock, patch
-
-import pytest
-from flask import Flask
-
-from iatoolkit.services.excel_service import ExcelService
-from iatoolkit.common.util import Utility
-
-
-class TestExcelService:
-    @pytest.fixture(autouse=True)
-    def setup(self):
-        self.app = Flask(__name__)
-        self.app.testing = True
-
-        # Create real temporary directory structure
-        self.temp_dir_base = tempfile.mkdtemp()
-        self.app.root_path = self.temp_dir_base
-        self.temp_dir = os.path.join(self.temp_dir_base, 'static', 'temp')
-        os.makedirs(self.temp_dir, exist_ok=True)
-
-        # Mocks of services
-        self.util = MagicMock(spec=Utility)
-        self.excel_service = ExcelService(util=self.util)
-
-        yield
-
-        # Cleanup after test
-        shutil.rmtree(self.temp_dir_base)
-
-    def create_test_file(self, filename, content=b'test content'):
-        file_path = os.path.join(self.temp_dir, filename)
-        with open(file_path, 'wb') as f:
-            f.write(content)
-        return file_path
-
-    def test_validate_file_access_valid_file(self):
-        filename = 'valid_file.xlsx'
-        self.create_test_file(filename)
-
-        with self.app.app_context():
-            with patch('iatoolkit.services.excel_service.current_app') as mock_current_app:
-                mock_current_app.root_path = self.temp_dir_base
-                result = self.excel_service.validate_file_access(filename)
-
-        assert result is None
-
-    def test_validate_file_access_path_traversal_dotdot(self):
-        filename = '../../../etc/passwd'
-
-        with self.app.app_context():
-            with patch('iatoolkit.services.excel_service.current_app') as mock_current_app:
-                mock_current_app.root_path = self.temp_dir_base
-                result = self.excel_service.validate_file_access(filename)
-
-        assert result is not None
-        data = result.get_json()
-        assert data['error'] == 'Nombre de archivo inválido'
-
-    def test_validate_file_access_path_traversal_absolute_unix(self):
-        filename = '/etc/passwd'
-
-        with self.app.app_context():
-            with patch('iatoolkit.services.excel_service.current_app') as mock_current_app:
-                mock_current_app.root_path = self.temp_dir_base
-                result = self.excel_service.validate_file_access(filename)
-
-        assert result is not None
-        data = result.get_json()
-        assert data['error'] == 'Nombre de archivo inválido'
-
-    def test_validate_file_access_path_traversal_backslash(self):
-        filename = 'folder\\..\\sensitive_file.txt'
-
-        with self.app.app_context():
-            with patch('iatoolkit.services.excel_service.current_app') as mock_current_app:
-                mock_current_app.root_path = self.temp_dir_base
-                result = self.excel_service.validate_file_access(filename)
-
-        assert result is not None
-        data = result.get_json()
-        assert data['error'] == 'Nombre de archivo inválido'
-
-    def test_validate_file_access_file_not_found(self):
-        filename = 'non_existent_file.xlsx'
-
-        with self.app.app_context():
-            with patch('iatoolkit.services.excel_service.current_app') as mock_current_app:
-                mock_current_app.root_path = self.temp_dir_base
-                result = self.excel_service.validate_file_access(filename)
-
-        assert result is not None
-        data = result.get_json()
-        assert data['error'] == 'Archivo no encontrado'
-
-    def test_validate_file_access_is_directory(self):
-        dirname = 'test_directory'
-        dir_path = os.path.join(self.temp_dir, dirname)
-        os.makedirs(dir_path)
-
-        with self.app.app_context():
-            with patch('iatoolkit.services.excel_service.current_app') as mock_current_app:
-                mock_current_app.root_path = self.temp_dir_base
-                result = self.excel_service.validate_file_access(dirname)
-
-        assert result is not None
-        data = result.get_json()
-        assert data['error'] == 'La ruta no corresponde a un archivo'
-
-    def test_validate_file_access_exception_handling(self):
-        filename = 'test_file.xlsx'
-
-        with self.app.app_context():
-            with patch('iatoolkit.services.excel_service.current_app') as mock_current_app:
-                mock_current_app.root_path = self.temp_dir_base
-                with patch('iatoolkit.services.excel_service.os.path.exists', side_effect=Exception("Test exception")):
-                    result = self.excel_service.validate_file_access(filename)
-
-        assert result is not None
-        data = result.get_json()
-        assert data['error'] == 'Error validando archivo'
-
-    def test_validate_file_access_logs_exception(self):
-        filename = 'test_file.xlsx'
-
-        with patch('iatoolkit.services.excel_service.logging') as mock_logging:
-            with patch('iatoolkit.services.excel_service.os.path.exists', side_effect=Exception("Test exception")):
-                with self.app.app_context():
-                    with patch('iatoolkit.services.excel_service.current_app') as mock_current_app:
-                        mock_current_app.root_path = self.temp_dir_base
-                        self.excel_service.validate_file_access(filename)
-
-        mock_logging.error.assert_called_once()
-        error_msg = mock_logging.error.call_args[0][0]
-        assert 'Error validando acceso al archivo test_file.xlsx' in error_msg
-        assert 'Test exception' in error_msg
-
-    def test_validate_file_access_various_valid_filenames(self):
-        with self.app.app_context():
-            with patch('iatoolkit.services.excel_service.current_app') as mock_current_app:
-                mock_current_app.root_path = self.temp_dir_base
-
-                valid_filenames = [
-                    'simple.xlsx',
-                    'file_with_underscores.xlsx',
-                    'file-with-dashes.xlsx',
-                    'file with spaces.xlsx',
-                    'file123.xlsx',
-                    'UPPERCASE.XLSX',
-                    'file.with.dots.xlsx'
-                ]
-
-                for filename in valid_filenames:
-                    self.create_test_file(filename)
-                    result = self.excel_service.validate_file_access(filename)
-                    assert result is None, f"Filename '{filename}' should be valid"
-
-    def test_validate_file_access_various_invalid_filenames(self):
-        with self.app.app_context():
-            with patch('iatoolkit.services.excel_service.current_app') as mock_current_app:
-                mock_current_app.root_path = self.temp_dir_base
-
-                invalid_filenames = [
-                    '../file.xlsx',
-                    '../../file.xlsx',
-                    '/absolute/path/file.xlsx',
-                    'folder\\file.xlsx',
-                    '..\\file.xlsx',
-                    'file..xlsx/../other.xlsx',
-                    '/etc/passwd',
-                    'C:\\Windows\\System32\\config'
-                ]
-
-                for filename in invalid_filenames:
-                    result = self.excel_service.validate_file_access(filename)
-                    assert result is not None, f"Filename '{filename}' should be invalid"
-                    data = result.get_json()
-                    assert data['error'] == 'Nombre de archivo inválido'
-
-    def test_validate_file_access_empty_filename(self):
-        filename = ''
-
-        with self.app.app_context():
-            with patch('iatoolkit.services.excel_service.current_app') as mock_current_app:
-                mock_current_app.root_path = self.temp_dir_base
-                result = self.excel_service.validate_file_access(filename)
-
-        assert result is not None
-        data = result.get_json()
-        assert data['error'] == 'Nombre de archivo inválido'
-
-    def test_validate_file_access_none_filename(self):
-        with self.app.app_context():
-            with patch('iatoolkit.services.excel_service.current_app') as mock_current_app:
-                mock_current_app.root_path = self.temp_dir_base
-                result = self.excel_service.validate_file_access(None)
-
-        assert result is not None
-        data = result.get_json()
-        assert data['error'] == 'Nombre de archivo inválido'

tests/services/test_file_processor_service.py

@@ -1,121 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import pytest
-from unittest.mock import MagicMock, patch
-from iatoolkit.services.file_processor_service import FileProcessor, FileProcessorConfig
-from iatoolkit.infra.connectors.file_connector import FileConnector
-
-
-class TestFileProcessor:
-    def setup_method(self):
-        # Mock del conector de archivos
-        self.mock_connector = MagicMock(spec=FileConnector)
-
-        # Acción de ejemplo para la configuración
-        self.mock_callback = MagicMock()
-        self.mock_company = MagicMock()
-
-        # Configuración del FileProcessorConfig con validaciones y mocks
-        self.mock_config = FileProcessorConfig(
-            log_file="mock_log_file.log",  # Archivo de log ficticio
-            callback=self.mock_callback,  # Acción mockeada
-            filters={
-                "filename_contains": "test",
-                "custom_filter": lambda x: x.endswith(".txt")  # Solo procesar archivos .txt
-            },
-            echo=True,
-            continue_on_error=True,
-            context={'company': self.mock_company,}
-        )
-
-        # Creamos la instancia de FileProcessor con los mocks
-        self.processor = FileProcessor(
-            self.mock_connector,
-            self.mock_config
-        )
-
-        self.mock_connector.list_files.return_value = [
-            {'path': "/mock/directory/test_file.txt",
-             'name': 'test_file.txt'}
-        ]
-
-    def test_process_files_when_exception_on_list_files(self):
-        # Generar un error intencional al abrir un archivo
-        self.mock_connector.list_files.side_effect = Exception("list file error")
-
-        status = self.processor.process_files()
-        assert status == False
-
-    def test_process_files_when_exception_on_get_content(self):
-        self.mock_connector.get_file_content.side_effect = Exception("Mocked error")
-
-        # Mock del logger para capturar errores
-        with patch.object(self.processor, "logger") as mock_logger:
-            # Ejecutar el método y permitir que continúe tras el error
-            self.processor.process_files()
-
-            # Verificar que no se ejecutó la acción debido al error
-            self.mock_callback.assert_not_called()
-
-            # Verificar que el logger capture el error
-            mock_logger.error.assert_called_once_with("Error processing /mock/directory/test_file.txt: Mocked error")
-
-    def test_process_files_filtered_out(self):
-        """Prueba que se filtren los archivos que no coincidan con los filtros."""
-        self.mock_connector.list_files.return_value = [
-            {'path': "/mock/directory/test_file1.doc",
-             'name': 'test_file1.doc'},
-            {'path': "/mock/directory/test_file2.txt",
-             'name': 'test_file2.txt'}
-        ]
-
-        self.mock_connector.get_file_content.return_value = b"content of file2"
-
-        self.processor.process_files()
-
-        # Solo debe procesarse test_file2.txt
-        self.mock_callback.assert_called_once_with(
-            company=self.mock_company,
-            filename="test_file2.txt",
-            content=b"content of file2",
-            context={'company': self.mock_company})
-        assert self.mock_callback.call_count == 1
-        assert self.mock_connector.get_file_content.call_count == 1
-
-    def test_process_files_stop_on_error(self):
-        """Prueba que se detenga el procesamiento si `continue_on_error` es False."""
-        self.mock_config.continue_on_error = False  # Configuración para detenerse en errores
-        self.mock_connector.get_file_content.side_effect = Exception("Mocked error")
-
-        # Verificar que se lanza la excepción y no continúa procesando
-        with pytest.raises(Exception, match="Mocked error"):
-            self.processor.process_files()
-
-        # No se debe haber realizado ninguna acción
-        self.mock_callback.assert_not_called()
-
-    def test_process_files_success(self):
-        self.mock_connector.list_files.return_value = [
-            {'path': "/mock/directory/test_file1.txt",
-             'name': 'test_file1.txt'},
-            {'path': "/mock/directory/test_file2.txt",
-             'name': 'test_file2.txt'}
-        ]
-        self.mock_connector.get_file_content.side_effect = [
-            b"content of file1",
-            b"content of file2",
-        ]
-
-        self.processor.process_files()
-
-        # Verificar que se llamaron las acciones con los archivos correctos
-        assert self.mock_callback.call_count == 2  # Solo archivos filtrados
-
-        # Verificar numero de archivos procesados
-        assert self.processor.processed_files == 2
-
-        # Verificar las llamadas al logger (si es necesario)
-        self.mock_connector.list_files.assert_called_once()

tests/services/test_history_service.py

@@ -1,164 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import pytest
-from unittest.mock import MagicMock
-from iatoolkit.services.history_service import HistoryService
-from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
-from iatoolkit.repositories.profile_repo import ProfileRepo
-from iatoolkit.repositories.models import LLMQuery, Company
-from iatoolkit.common.util import Utility
-from iatoolkit.common.session_manager import SessionManager
-from unittest.mock import patch
-
-
-class TestHistoryService:
-    @pytest.fixture(autouse=True)
-    def setup(self):
-        self.llm_query_repo = MagicMock(spec=LLMQueryRepo)
-        self.profile_repo = MagicMock(spec=ProfileRepo)
-        # Usamos la clase Utility real para asegurar que la lógica de resolución de ID es correcta
-        self.util = Utility()
-        self.history_service = HistoryService(
-            llm_query_repo=self.llm_query_repo,
-            profile_repo=self.profile_repo,
-            util=self.util
-        )
-        # Mock común para la compañía
-        self.mock_company = MagicMock(spec=Company)
-        self.mock_company.id = 1
-        self.mock_company.name = 'Test Company'
-        self.profile_repo.get_company_by_short_name.return_value = self.mock_company
-
-    def test_get_history_company_not_found(self):
-        """Prueba que el servicio devuelve un error si la empresa no se encuentra."""
-        self.profile_repo.get_company_by_short_name.return_value = None
-
-        result = self.history_service.get_history(
-            company_short_name='nonexistent_company',
-            external_user_id='test_user'
-        )
-
-        assert result == {'error': 'No existe la empresa: nonexistent_company'}
-        self.profile_repo.get_company_by_short_name.assert_called_once_with('nonexistent_company')
-        self.llm_query_repo.get_history.assert_not_called()
-
-    def test_get_history_no_history_found(self):
-        """Prueba que el servicio devuelve un error si no se encuentra historial."""
-        self.llm_query_repo.get_history.return_value = []
-        user_identifier = 'test_user'
-
-        result = self.history_service.get_history(
-            company_short_name='test_company',
-            external_user_id=user_identifier
-        )
-
-        assert result == {'error': 'No se pudo obtener el historial'}
-        self.profile_repo.get_company_by_short_name.assert_called_once_with('test_company')
-        self.llm_query_repo.get_history.assert_called_once_with(self.mock_company, user_identifier)
-
-    def test_get_history_success_with_external_user_id(self):
-        """Prueba la recuperación exitosa del historial usando un external_user_id."""
-        user_identifier = 'external_user_123'
-
-        mock_query1 = MagicMock(spec=LLMQuery)
-        mock_query1.to_dict.return_value = {'id': 1, 'query': 'q1', 'answer': 'a1', 'created_at': 't1'}
-        mock_query2 = MagicMock(spec=LLMQuery)
-        mock_query2.to_dict.return_value = {'id': 2, 'query': 'q2', 'answer': 'a2', 'created_at': 't2'}
-
-        self.llm_query_repo.get_history.return_value = [mock_query1, mock_query2]
-
-        result = self.history_service.get_history(
-            company_short_name='test_company',
-            external_user_id=user_identifier
-        )
-
-        assert result['message'] == 'Historial obtenido correctamente'
-        assert len(result['history']) == 2
-        assert result['history'][0]['id'] == 1
-
-        self.llm_query_repo.get_history.assert_called_once_with(self.mock_company, user_identifier)
-
-    def test_get_history_success_with_local_user_id_and_external_id_takes_precedence(self):
-        """Prueba que external_user_id tiene prioridad sobre local_user_id."""
-        external_user_identifier = 'external_user_abc'
-
-        mock_query = MagicMock(spec=LLMQuery)
-        mock_query.to_dict.return_value = {'id': 1}
-        self.llm_query_repo.get_history.return_value = [mock_query]
-
-        result = self.history_service.get_history(
-            company_short_name='test_company',
-            external_user_id=external_user_identifier,
-            local_user_id=123  # Este debería ser ignorado
-        )
-
-        assert 'history' in result
-        # El user_identifier resuelto debe ser el ID externo.
-        self.llm_query_repo.get_history.assert_called_once_with(self.mock_company, external_user_identifier)
-
-    def test_get_history_success_with_local_user_id_only(self):
-        local_id = 456
-        resolved_user_identifier = 'fl@gmail.com'
-
-        with patch('iatoolkit.common.session_manager.session', new={}) as fake_session:
-            SessionManager.set('user', {'id': local_id, 'email': resolved_user_identifier})
-
-            mock_query = MagicMock(spec=LLMQuery)
-            mock_query.to_dict.return_value = {'id': 1, 'query': 'q1'}
-            self.llm_query_repo.get_history.return_value = [mock_query]
-
-            result = self.history_service.get_history(
-                company_short_name='test_company',
-                local_user_id=local_id
-            )
-
-        assert result['message'] == 'Historial obtenido correctamente'
-        self.llm_query_repo.get_history.assert_called_once_with(self.mock_company, resolved_user_identifier)
-
-    def test_get_history_fails_when_no_user_identifier_is_provided(self):
-        """Prueba que falla si no se proporciona ningún identificador de usuario."""
-        result = self.history_service.get_history(company_short_name='test_company')
-
-        assert result == {'error': 'No se pudo resolver el identificador del usuario'}
-        self.llm_query_repo.get_history.assert_not_called()
-
-    def test_get_history_propagates_exception_from_company_lookup(self):
-        """Prueba que las excepciones de la capa de repositorio se propagan."""
-        self.profile_repo.get_company_by_short_name.side_effect = Exception('Database error')
-
-        result = self.history_service.get_history(
-            company_short_name='test_company',
-            external_user_id='test_user'
-        )
-
-        assert result == {'error': 'Database error'}
-        self.llm_query_repo.get_history.assert_not_called()
-
-    def test_get_history_propagates_exception_from_history_lookup(self):
-        """Prueba que las excepciones de la capa de repositorio se propagan."""
-        user_identifier = 'test_user'
-        self.llm_query_repo.get_history.side_effect = Exception('History lookup error')
-
-        result = self.history_service.get_history(
-            company_short_name='test_company',
-            external_user_id=user_identifier
-        )
-
-        assert result == {'error': 'History lookup error'}
-        self.llm_query_repo.get_history.assert_called_once_with(self.mock_company, user_identifier)
-
-    def test_get_history_none_returned_from_repo(self):
-        """Prueba el caso en que el repositorio devuelve None."""
-        self.llm_query_repo.get_history.return_value = None
-        user_identifier = 'test_user'
-
-        result = self.history_service.get_history(
-            company_short_name='test_company',
-            external_user_id=user_identifier
-        )
-
-        assert result == {'error': 'No se pudo obtener el historial'}
-        self.llm_query_repo.get_history.assert_called_once_with(self.mock_company, user_identifier)