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

tests/infra/connectors/test_local_file_connector.py

@@ -1,85 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import pytest
-import os
-from unittest.mock import patch, mock_open, call
-from iatoolkit.infra.connectors.local_file_connector import LocalFileConnector
-from iatoolkit.common.exceptions import IAToolkitException
-from datetime import datetime
-
-
-class TestLocalFileConnector:
-    def setup_method(self):
-        self.mock_directory = "/mock/directory"
-        self.file_connector = LocalFileConnector(self.mock_directory)
-
-    @patch("os.listdir", side_effect=Exception("Error al listar directorio"))
-    def test_list_files_error(self, mock_listdir):
-        with pytest.raises(IAToolkitException) as excinfo:
-            self.file_connector.list_files()
-
-        assert excinfo.value.error_type == IAToolkitException.ErrorType.FILE_IO_ERROR
-        assert "Error procesando el directorio" in str(excinfo.value)
-        mock_listdir.assert_called_once_with(self.mock_directory)
-
-    @patch("os.path.getmtime")
-    @patch("os.path.getsize")
-    @patch("os.listdir")
-    @patch("os.path.isfile")
-    def test_list_files_success(self, mock_isfile, mock_listdir,
-                                mock_getsize, mock_getmtime):
-        # Configurar mocks
-        mock_listdir.return_value = ["file1.txt", "file2.pdf", "subdir"]
-        mock_isfile.side_effect = lambda path: not path.endswith("subdir")
-        mock_getsize.return_value = 100
-        mock_getmtime.return_value = datetime(2024, 2, 19, 15, 30)
-
-        expected_return = [
-            {
-                'name': "file1.txt", 'path': '/mock/directory/file1.txt',
-                'metadata': {'size': 100, 'last_modified': mock_getmtime.return_value}
-            },
-            {
-                'name': "file2.pdf", 'path': '/mock/directory/file2.pdf',
-                'metadata': {'size': 100, 'last_modified': mock_getmtime.return_value}
-            }
-        ]
-
-
-        result = self.file_connector.list_files()
-
-        assert result == expected_return
-        mock_listdir.assert_called_once_with(self.mock_directory)
-        mock_isfile.assert_has_calls([
-            call(os.path.join(self.mock_directory, "file1.txt")),
-            call(os.path.join(self.mock_directory, "file2.pdf")),
-            call(os.path.join(self.mock_directory, "subdir")),
-        ])
-
-
-    @patch("builtins.open", side_effect=Exception("Error al abrir el archivo"))
-    def test_get_file_content_error(self, mock_open_file):
-        """Prueba para verificar que `get_file_content` lanza una excepción en caso de error."""
-        mock_file_path = os.path.join(self.mock_directory, "file1.txt")
-
-        # Verificar que se lanza la excepción esperada
-        with pytest.raises(IAToolkitException) as excinfo:
-            self.file_connector.get_file_content(mock_file_path)
-
-        assert excinfo.value.error_type == IAToolkitException.ErrorType.FILE_IO_ERROR
-        assert "Error leyendo el archivo" in str(excinfo.value)
-        mock_open_file.assert_called_once_with(mock_file_path, "rb")
-
-    @patch("builtins.open", new_callable=mock_open, read_data=b"file content")
-    def test_get_file_content_success(self, mock_open_file):
-        mock_file_path = os.path.join(self.mock_directory, "file1.txt")
-
-        result = self.file_connector.get_file_content(mock_file_path)
-
-        # Verificaciones
-        assert result == b"file content"
-        mock_open_file.assert_called_once_with(mock_file_path, "rb")
-

tests/infra/connectors/test_s3_connector.py

@@ -1,95 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import unittest
-from unittest.mock import patch, MagicMock
-from iatoolkit.infra.connectors.s3_connector import S3Connector
-
-
-class TestS3Connector(unittest.TestCase):
-    def setUp(self):
-        # Mock de `boto3.client`
-        self.boto3_client_patch = patch('iatoolkit.infra.connectors.s3_connector.boto3.client')
-        self.mock_boto3_client = self.boto3_client_patch.start()
-
-        # Mock del cliente S3
-        self.mock_s3_client = MagicMock()
-        self.mock_boto3_client.return_value = self.mock_s3_client
-
-        # Configuración básica
-        self.bucket = "test-bucket"
-        self.prefix = "test-prefix/"
-        self.auth = {
-            "aws_access_key_id": "mock-key",
-            "aws_secret_access_key": "mock-secret",
-            "region_name": "us-east-1"
-        }
-
-        # Crear una instancia del conector con los mocks
-        self.connector = S3Connector(bucket=self.bucket, prefix=self.prefix, auth=self.auth)
-
-    def tearDown(self):
-        self.boto3_client_patch.stop()
-
-    def test_init_when_boto3_client_error(self):
-        self.mock_boto3_client.side_effect = Exception("Failed to create boto3 client")
-
-        with self.assertRaises(Exception) as context:
-            S3Connector(bucket=self.bucket, prefix=self.prefix, auth=self.auth)
-
-        # Validar que el mensaje de la excepción coincide
-        self.assertEqual(str(context.exception), "Failed to create boto3 client")
-
-    def test_list_files_empty(self):
-        self.mock_s3_client.list_objects_v2.return_value = {}
-
-        result = self.connector.list_files()
-        self.assertEqual(result, [])
-
-    def test_list_files_success(self):
-        # Simulación de respuesta de `list_objects_v2`
-        self.mock_s3_client.list_objects_v2.return_value = {
-            "Contents": [
-                {
-                    "Key": "test-prefix/file1.txt",
-                    "Size": 1024,
-                    "LastModified": "2023-01-01T12:00:00.000Z"
-                },
-                {
-                    "Key": "test-prefix/file2.txt",
-                    "Size": 2048,
-                    "LastModified": "2023-01-02T12:00:00.000Z"
-                }
-            ]
-        }
-
-        result = self.connector.list_files()
-
-        self.assertEqual(len(result), 2)
-        self.assertEqual(result[0]['path'], "test-prefix/file1.txt")
-        self.assertEqual(result[0]['name'], "file1.txt")
-        self.assertEqual(result[0]['metadata']['size'], 1024)
-        self.assertEqual(result[0]['metadata']['last_modified'], "2023-01-01T12:00:00.000Z")
-
-
-    def test_get_file_content_not_found(self):
-        # Simulación de excepción de archivo no encontrado
-        self.mock_s3_client.get_object.side_effect = Exception("NoSuchKey")
-
-        # Llamada al método y capturar excepción
-        with self.assertRaises(Exception) as context:
-            self.connector.get_file_content("test-prefix/nonexistent.txt")
-
-        # Validar la excepción
-        self.assertEqual(str(context.exception), "NoSuchKey")
-
-    def test_get_file_content_success(self):
-        # Simulación de respuesta de `get_object`
-        mock_body = MagicMock()
-        mock_body.read.return_value = b"mock file content"
-        self.mock_s3_client.get_object.return_value = {"Body": mock_body}
-
-        result = self.connector.get_file_content("test-prefix/file1.txt")
-        self.assertEqual(result, b"mock file content")

tests/infra/test_call_service.py

@@ -1,92 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import pytest
-from unittest.mock import patch, MagicMock
-from iatoolkit.infra.call_service import CallServiceClient
-from requests import RequestException
-from iatoolkit.common.exceptions import IAToolkitException
-
-
-class TestCallServiceClient:
-
-    def setup_method(self):
-        self.client = CallServiceClient()
-        self.endpoint = "http://fake-endpoint.com/api/test"
-        self.mock_response = MagicMock()
-        self.mock_response.json.return_value = {'result': 'ok'}
-        self.mock_response.status_code = 200
-
-        # Patch 'requests' methods
-        self.get_patcher = patch('iatoolkit.infra.call_service.requests.get', return_value=self.mock_response)
-        self.post_patcher = patch('iatoolkit.infra.call_service.requests.post', return_value=self.mock_response)
-        self.put_patcher = patch('iatoolkit.infra.call_service.requests.put', return_value=self.mock_response)
-        self.patch_patcher = patch('iatoolkit.infra.call_service.requests.patch', return_value=self.mock_response)
-        self.delete_patcher = patch('iatoolkit.infra.call_service.requests.delete', return_value=self.mock_response)
-
-        # Start patching
-        self.mock_get = self.get_patcher.start()
-        self.mock_post = self.post_patcher.start()
-        self.mock_put = self.put_patcher.start()
-        self.mock_patch = self.patch_patcher.start()
-        self.mock_delete = self.delete_patcher.start()
-
-    def teardown_method(self):
-        patch.stopall()
-
-    def test_get_success(self):
-        response, status = self.client.get(self.endpoint)
-        self.mock_get.assert_called_once_with(self.endpoint,
-                                              headers= {'Content-Type': 'application/json'},
-                                              params=None, timeout=(10, 10.0))
-        assert status == 200
-        assert response == {'result': 'ok'}
-
-    def test_get_failure(self):
-        self.mock_get.side_effect = RequestException("Failed GET")
-
-        with pytest.raises(IAToolkitException) as exc_info:
-            self.client.get(self.endpoint)
-
-        assert exc_info.value.error_type == IAToolkitException.ErrorType.REQUEST_ERROR
-
-    def test_post_success(self):
-        json_dict = {'key': 'value'}
-        response, status = self.client.post(self.endpoint, json_dict)
-        self.mock_post.assert_called_once_with(self.endpoint, json=json_dict,
-                                               headers=self.client.headers,
-                                               params=None,
-                                               timeout=(10, 10.0))
-        assert status == 200
-        assert response == {'result': 'ok'}
-
-    def test_post_failure(self):
-        self.mock_post.side_effect = RequestException("Failed POST")
-
-        with pytest.raises(IAToolkitException) as exc_info:
-            self.client.post(self.endpoint, {'data': 'test'})
-
-        assert exc_info.value.error_type == IAToolkitException.ErrorType.REQUEST_ERROR
-
-    def test_put_success(self):
-        json_dict = {'key': 'updated'}
-        response, status = self.client.put(self.endpoint, json_dict)
-        assert status == 200
-        assert response == {'result': 'ok'}
-
-
-    def test_delete_success(self):
-        json_dict = {'key': 'deleted'}
-        response, status = self.client.delete(self.endpoint, json_dict)
-
-        assert status == 200
-        assert response == {'result': 'ok'}
-
-    def test_post_files_success(self):
-        files = {'file': ('filename.txt', 'filecontent')}
-        response, status = self.client.post_files(self.endpoint, files)
-        assert status == 200
-        assert response == {'result': 'ok'}
-

tests/infra/test_database_manager.py

@@ -1,59 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import unittest
-from unittest.mock import patch, MagicMock
-from iatoolkit.repositories.database_manager import DatabaseManager
-
-
-class TestDatabaseManager(unittest.TestCase):
-
-    @patch('iatoolkit.repositories.database_manager.create_engine')
-    @patch('iatoolkit.repositories.database_manager.sessionmaker')
-    @patch('iatoolkit.repositories.database_manager.scoped_session')
-    def setUp(self, mock_scoped_session, mock_sessionmaker, mock_create_engine):
-        """Configura mocks para las dependencias principales de DatabaseManager."""
-        # Mock del motor y las sesiones
-        self.mock_engine = MagicMock()
-        mock_create_engine.return_value = self.mock_engine
-
-        self.mock_sessionmaker = MagicMock()
-        mock_sessionmaker.return_value = self.mock_sessionmaker
-
-        self.mock_scoped_session = MagicMock()
-        mock_scoped_session.return_value = self.mock_scoped_session
-
-        # Instanciar el DatabaseManager con un mock de URL de base de datos
-        self.db_manager = DatabaseManager("sqlite:///:memory:")
-
-        # Verificaciones iniciales
-        mock_create_engine.assert_called_once_with("sqlite:///:memory:", echo=False)
-        mock_sessionmaker.assert_called_once_with(bind=self.mock_engine)
-        mock_scoped_session.assert_called_once_with(self.mock_sessionmaker)
-
-    def test_get_session(self):
-        """Prueba que get_session devuelve una nueva sesión."""
-        session = self.db_manager.get_session()
-        self.mock_scoped_session.assert_called_once()
-        self.assertEqual(session, self.mock_scoped_session())
-
-    @patch('iatoolkit.repositories.database_manager.Base.metadata.create_all')
-    def test_create_all(self, mock_create_all):
-        """Prueba que create_all crea las tablas usando la metadata de Base."""
-        self.db_manager.create_all()
-        mock_create_all.assert_called_once_with(self.mock_engine)
-
-    @patch('iatoolkit.repositories.database_manager.Base.metadata.drop_all')
-    def test_drop_all(self, mock_drop_all):
-        """Prueba que drop_all elimina las tablas usando la metadata de Base."""
-        self.db_manager.drop_all()
-        mock_drop_all.assert_called_once_with(self.mock_engine)
-
-    def test_remove_session(self):
-        """Prueba que remove_session limpia la sesión actual."""
-        self.db_manager.remove_session()
-        self.mock_scoped_session.remove.assert_called_once()
-
-

tests/infra/test_gemini_adapter.py

@@ -1,137 +0,0 @@
-import pytest
-from unittest.mock import patch, MagicMock
-import uuid
-import json
-
-from iatoolkit.infra.gemini_adapter import GeminiAdapter
-from iatoolkit.infra.llm_response import LLMResponse, ToolCall
-from iatoolkit.common.exceptions import IAToolkitException
-
-
-class TestGeminiAdapter:
-    """Tests para la clase GeminiAdapter."""
-
-    def setup_method(self):
-        """Configura el entorno de prueba antes de cada test."""
-        self.mock_gemini_client = MagicMock()
-        self.mock_generative_model = MagicMock()
-        self.mock_gemini_client.GenerativeModel.return_value = self.mock_generative_model
-        self.adapter = GeminiAdapter(gemini_client=self.mock_gemini_client)
-
-        patch('iatoolkit.infra.gemini_adapter.uuid.uuid4', return_value=uuid.UUID('12345678-1234-5678-1234-567812345678')).start()
-
-        self.message_to_dict_patcher = patch('iatoolkit.infra.gemini_adapter.MessageToDict')
-        self.mock_message_to_dict = self.message_to_dict_patcher.start()
-
-    def teardown_method(self):
-        patch.stopall()
-
-    def _create_mock_gemini_response(self, text_content=None, function_call=None, finish_reason="STOP",
-                                     usage_metadata=None):
-        """Crea un objeto de respuesta mock de Gemini de forma robusta."""
-        mock_response = MagicMock()
-        parts = []
-
-        if text_content:
-            part = MagicMock()
-            part.text = text_content
-            # Nos aseguramos que el otro atributo no exista para evitar ambigüedad
-            del part.function_call
-            parts.append(part)
-
-        if function_call:
-            # Crea un mock para el objeto `function_call` y asigna sus atributos directamente.
-            mock_fc_obj = MagicMock()
-            mock_fc_obj.name = function_call['name']
-            mock_fc_obj._pb = "mock_pb"  # Simular el objeto protobuf interno
-
-            # Configura el mock del conversor para que devuelva los args esperados
-            self.mock_message_to_dict.return_value = {'args': function_call['args']}
-
-            part = MagicMock()
-            part.function_call = mock_fc_obj
-            del part.text
-            parts.append(part)
-
-        mock_candidate = MagicMock()
-        mock_candidate.content.parts = parts
-        mock_candidate.finish_reason = finish_reason
-        mock_response.candidates = [mock_candidate]
-
-        if usage_metadata:
-            mock_response.usage_metadata = MagicMock(**usage_metadata)
-        else:
-            del mock_response.usage_metadata
-
-        return mock_response
-
-    def test_create_response_text_only(self):
-        """Prueba una llamada simple que devuelve solo texto."""
-        mock_response = self._create_mock_gemini_response(text_content="Hola mundo")
-        self.mock_generative_model.generate_content.return_value = mock_response
-
-        response = self.adapter.create_response(model="gemini-pro", input=[])
-
-        assert isinstance(response, LLMResponse)
-        assert response.output_text == "Hola mundo"
-        assert len(response.output) == 0
-
-    def test_create_response_text_with_history(self):
-        """Prueba una llamada simple que devuelve solo texto."""
-        mock_response = self._create_mock_gemini_response(text_content="Hola mundo")
-        self.mock_generative_model.generate_content.return_value = mock_response
-
-        context_history = [{"role": "user", "content": "Pregunta"}]
-
-        response = self.adapter.create_response(model="gemini-pro",
-                                                input=[],
-                                                context_history=context_history)
-
-        assert isinstance(response, LLMResponse)
-        assert response.output_text == "Hola mundo"
-        assert len(context_history) == 2
-
-    def test_create_response_with_tool_call(self):
-        """Prueba una llamada que devuelve una function_call."""
-        func_call_data = {'name': 'get_weather', 'args': {'location': 'Santiago'}}
-        mock_response = self._create_mock_gemini_response(function_call=func_call_data)
-        self.mock_generative_model.generate_content.return_value = mock_response
-
-        response = self.adapter.create_response(model="gemini-flash", input=[], tools=[{}])
-
-        assert len(response.output) == 1
-        tool_call = response.output[0]
-        assert isinstance(tool_call, ToolCall)
-        assert tool_call.name == "get_weather"
-        assert tool_call.arguments == json.dumps(func_call_data['args'])
-        self.mock_message_to_dict.assert_called_once_with("mock_pb")
-
-    def test_history_not_modified_if_no_content_in_response(self):
-        """Prueba que el historial no se modifica si la respuesta está vacía."""
-        mock_response = self._create_mock_gemini_response()  # Sin texto ni tool calls
-        self.mock_generative_model.generate_content.return_value = mock_response
-
-        context_history = [{"role": "user", "content": "Pregunta"}]
-        self.adapter.create_response(model="gemini-pro", input=[], context_history=context_history)
-
-        assert len(context_history) == 1  # El historial no debe cambiar
-
-    @pytest.mark.parametrize("error_msg, expected_app_msg", [
-        ("Quota exceeded", "Se ha excedido la cuota de la API de Gemini"),
-        ("Content blocked", "El contenido fue bloqueado"),
-        ("Invalid token", "Tu consulta supera el límite de contexto de Gemini"),
-        ("Other API error", "Error calling Gemini API: Other API error"),
-    ])
-    def test_api_error_handling(self, error_msg, expected_app_msg):
-        self.mock_generative_model.generate_content.side_effect = Exception(error_msg)
-        with pytest.raises(IAToolkitException, match=expected_app_msg):
-            self.adapter.create_response(model="gemini-pro", input=[])
-
-    @pytest.mark.parametrize("finish_reason, expected_status", [
-        ("SAFETY", "blocked"), ("MAX_TOKENS", "length_exceeded"), ("STOP", "completed")
-    ])
-    def test_map_finish_reason_to_status(self, finish_reason, expected_status):
-        mock_response = self._create_mock_gemini_response(finish_reason=finish_reason)
-        self.mock_generative_model.generate_content.return_value = mock_response
-        response = self.adapter.create_response(model="gemini-pro", input=[])
-        assert response.status == expected_status

tests/infra/test_google_chat_app.py

@@ -1,68 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import pytest
-from unittest.mock import Mock, patch
-from iatoolkit.infra.google_chat_app import GoogleChatApp
-
-
-class TestGoogleChatApp:
-    @pytest.fixture
-    def mock_call_service(self):
-        return Mock()
-
-    @pytest.fixture
-    def google_chat_service(self, mock_call_service):
-        return GoogleChatApp(mock_call_service)
-
-    def test_send_message_success(self, google_chat_service, mock_call_service):
-        # Configurar el mock
-        mock_call_service.post.return_value = ({"status": "sent"}, 200)
-
-        message_data = {
-            "type": "MESSAGE_TRIGGER",
-            "space": {
-                "name": "spaces/AAQAupQldd4"
-            },
-            "message": {
-                "text": "Test message"
-            }
-        }
-
-        with patch.dict('os.environ', {'GOOGLE_CHAT_BOT_URL': 'https://test-bot.com'}):
-            result = google_chat_service.send_message(message_data=message_data)
-
-        assert result['success'] is True
-        assert result['message'] == "Mensaje enviado correctamente"
-        mock_call_service.post.assert_called_once_with('https://test-bot.com', message_data)
-
-    def test_send_message_missing_env_var(self, google_chat_service):
-        message_data = {
-            "type": "MESSAGE_TRIGGER",
-            "space": {"name": "spaces/test"},
-            "message": {"text": "Test"}
-        }
-
-        with patch.dict('os.environ', {}, clear=True):
-            result = google_chat_service.send_message(message_data=message_data)
-
-        assert result['success'] is False
-        assert "GOOGLE_CHAT_BOT_URL no está configurada" in result['message']
-
-    def test_send_message_api_error(self, google_chat_service, mock_call_service):
-        # Configurar el mock para simular error
-        mock_call_service.post.return_value = ({"error": "API Error"}, 500)
-
-        message_data = {
-            "type": "MESSAGE_TRIGGER",
-            "space": {"name": "spaces/test"},
-            "message": {"text": "Test"}
-        }
-
-        with patch.dict('os.environ', {'GOOGLE_CHAT_BOT_URL': 'https://test-bot.com'}):
-            result = google_chat_service.send_message(message_data=message_data)
-
-        assert result['success'] is False
-        assert "Error al enviar mensaje" in result['message']