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

tests/infra/test_llm_client.py

@@ -1,165 +0,0 @@
-# tests/test_llm_client.py
-
-import pytest
-from unittest.mock import patch, MagicMock
-from iatoolkit.infra.llm_client import llmClient
-from iatoolkit.infra.llm_response import LLMResponse, ToolCall, Usage
-from iatoolkit.common.exceptions import IAToolkitException
-from iatoolkit.repositories.models import Company
-import json
-
-
-class TestLLMClient:
-    def setup_method(self):
-        """Setup común para todos los tests"""
-        # Mocks de dependencias inyectadas
-        self.dispatcher_mock = MagicMock()
-        self.llmquery_repo = MagicMock()
-        self.util_mock = MagicMock()
-        self.llm_proxy_factory = MagicMock()
-        self.injector_mock = MagicMock()
-
-        # Mock del LLMProxy que será devuelto por la fábrica
-        self.mock_proxy = MagicMock()
-        self.llm_proxy_factory.create_for_company.return_value = self.mock_proxy
-
-        # Mock company
-        self.company = Company(id=1, name='Test Company', short_name='test_company')
-
-        # Mock de variables de entorno
-        self.env_patcher = patch.dict('os.environ', {'LLM_MODEL': 'gpt-4o'})
-        self.env_patcher.start()
-
-        # Mock tiktoken
-        self.tiktoken_patcher = patch('iatoolkit.infra.llm_client.tiktoken')
-        self.mock_tiktoken = self.tiktoken_patcher.start()
-        self.mock_tiktoken.encoding_for_model.return_value = MagicMock()
-
-        # Instance of the client under test
-        self.client = llmClient(
-            llmquery_repo=self.llmquery_repo,
-            util=self.util_mock,
-            llm_proxy_factory=self.llm_proxy_factory
-        )
-
-        # Respuesta mock estándar del LLM
-        self.mock_llm_response = LLMResponse(
-            id='response_123', model='gpt-4o', status='completed',
-            output_text=json.dumps({"answer": "Test response", "aditional_data": {}}),
-            output=[], usage=Usage(input_tokens=100, output_tokens=50, total_tokens=150)
-        )
-
-    def teardown_method(self):
-        """Limpieza después de cada test"""
-        patch.stopall()
-
-    def test_init_missing_llm_model(self):
-        """Test que la inicialización falla si falta LLM_MODEL."""
-        with patch.dict('os.environ', {}, clear=True):
-            with pytest.raises(IAToolkitException, match="LLM_MODEL"):
-                llmClient(self.llmquery_repo, self.util_mock, self.llm_proxy_factory)
-
-    def test_invoke_success(self):
-        """Test de una llamada invoke exitosa."""
-        self.mock_proxy.create_response.return_value = self.mock_llm_response
-
-        result = self.client.invoke(
-            company=self.company, user_identifier='user1', previous_response_id='prev1',
-            question='q', context='c', tools=[], text={}
-        )
-
-        self.llm_proxy_factory.create_for_company.assert_called_once_with(self.company)
-        self.mock_proxy.create_response.assert_called_once()
-        assert result['valid_response'] is True
-        assert 'Test response' in result['answer']
-        assert result['response_id'] == 'response_123'
-        self.llmquery_repo.add_query.assert_called_once()
-
-    def test_invoke_handles_function_calls(self):
-        """Tests that invoke correctly handles function calls."""
-        # 1. Create a mock for the dispatcher service
-        dispatcher_mock = MagicMock()
-        dispatcher_mock.dispatch.return_value = '{"status": "ok"}'
-
-        # 2. Create a mock injector that knows how to provide the dispatcher mock
-        injector_mock = MagicMock()
-        injector_mock.get.return_value = dispatcher_mock
-
-        # 3. Create a mock IAToolkit instance
-        toolkit_mock = MagicMock()
-        # Make its _get_injector() method return our mock injector
-        toolkit_mock.get_injector.return_value = injector_mock
-
-        # 4. Use patch to replace `current_iatoolkit` with our mock toolkit
-        with patch('iatoolkit.current_iatoolkit', return_value=toolkit_mock):
-            # 5. Define the sequence of LLM responses
-            tool_call = ToolCall('call1', 'function_call', 'test_func', '{"a": 1}')
-            response_with_tools = LLMResponse('r1', 'gpt-4o', 'completed', '', [tool_call], Usage(10, 5, 15))
-            self.mock_proxy.create_response.side_effect = [response_with_tools, self.mock_llm_response]
-
-            # 6. Invoke the client. Now, when it calls current_iatoolkit, it will get our mock.
-            self.client.invoke(
-                company=self.company, user_identifier='user1', previous_response_id='prev1',
-                question='q', context='c', tools=[{}], text={}
-            )
-
-        # 7. Assertions
-        assert self.mock_proxy.create_response.call_count == 2
-
-        # Verify that the dispatcher was correctly retrieved and called
-        dispatcher_mock.dispatch.assert_called_once_with(
-            company_name='test_company', action='test_func', a=1
-        )
-
-        # Verify that the function output was reinjected into the history
-        second_call_args = self.mock_proxy.create_response.call_args_list[1].kwargs
-        function_output_message = second_call_args['input'][1]
-        assert function_output_message.get('type') == 'function_call_output'
-        assert function_output_message.get('output') == '{"status": "ok"}'
-
-    def test_invoke_llm_api_error_propagates(self):
-        """Test que los errores de la API del LLM se propagan como IAToolkitException."""
-        self.mock_proxy.create_response.side_effect = Exception("API Communication Error")
-
-        with pytest.raises(IAToolkitException, match="Error calling LLM API"):
-            self.client.invoke(
-                company=self.company, user_identifier='user1', previous_response_id='prev1',
-                question='q', context='c', tools=[], text={}
-            )
-        # Verificar que se guarda un registro de error en la BD
-        self.llmquery_repo.add_query.assert_called_once()
-        log_arg = self.llmquery_repo.add_query.call_args[0][0]
-        assert log_arg.valid_response is False
-        assert "API Communication Error" in log_arg.output
-
-    def test_set_company_context_success(self):
-        """Test de la configuración exitosa del contexto de la empresa."""
-        context_response = LLMResponse('ctx1', 'gpt-4o', 'completed', 'OK', [], Usage(10, 2, 12))
-        self.mock_proxy.create_response.return_value = context_response
-
-        response_id = self.client.set_company_context(
-            company=self.company, company_base_context="System prompt"
-        )
-
-        assert response_id == 'ctx1'
-        self.llm_proxy_factory.create_for_company.assert_called_once_with(self.company)
-        self.mock_proxy.create_response.assert_called_once()
-        call_args = self.mock_proxy.create_response.call_args.kwargs['input'][0]
-        assert call_args['role'] == 'system'
-        assert call_args['content'] == 'System prompt'
-
-    def test_decode_response_valid_json(self):
-        """Test de decodificación de una respuesta JSON válida."""
-        response = LLMResponse('r1', 'm1', 'completed', '```json\n{"answer": "hola"}\n```', [], Usage(1, 1, 2))
-
-        # Simular una respuesta con fallback
-        with patch('json.loads', return_value={'answer': 'hola'}):
-            decoded = self.client.decode_response(response)
-            assert decoded['answer_format'] == 'json_fallback'
-
-        # Simular una respuesta completa y válida
-        with patch('json.loads', return_value={'answer': 'hola', 'aditional_data': {}}):
-            decoded = self.client.decode_response(response)
-            assert decoded['status'] is True
-            assert decoded['answer'] == 'hola'
-            assert decoded['answer_format'] == 'json_string'

tests/infra/test_llm_proxy.py

@@ -1,122 +0,0 @@
-import pytest
-from unittest.mock import patch, MagicMock
-from iatoolkit.infra.llm_proxy import LLMProxy
-from iatoolkit.common.exceptions import IAToolkitException
-
-
-class TestLLMProxy:
-
-    def setup_method(self):
-        """Configuración común para las pruebas de LLMProxy."""
-        self.util_mock = MagicMock()
-        self.util_mock.decrypt_key.side_effect = lambda x: f"decrypted_{x}"
-
-        # Mocks para los clientes de los proveedores y sus adaptadores
-        self.openai_patcher = patch('iatoolkit.infra.llm_proxy.OpenAI')
-        self.gemini_patcher = patch('iatoolkit.infra.llm_proxy.genai')
-        self.openai_adapter_patcher = patch('iatoolkit.infra.llm_proxy.OpenAIAdapter')
-        self.gemini_adapter_patcher = patch('iatoolkit.infra.llm_proxy.GeminiAdapter')
-
-        self.mock_openai_class = self.openai_patcher.start()
-        self.mock_gemini_module = self.gemini_patcher.start()
-        self.mock_openai_adapter_class = self.openai_adapter_patcher.start()
-        self.mock_gemini_adapter_class = self.gemini_adapter_patcher.start()
-
-        self.mock_openai_adapter_instance = MagicMock()
-        self.mock_gemini_adapter_instance = MagicMock()
-        self.mock_openai_adapter_class.return_value = self.mock_openai_adapter_instance
-        self.mock_gemini_adapter_class.return_value = self.mock_gemini_adapter_instance
-
-        # --- Mocks de Compañías usando MagicMock para evitar TypeError ---
-
-        # Compañía con ambas claves
-        self.company_both = MagicMock()
-        self.company_both.short_name = 'comp_both'
-        self.company_both.name = 'Both'
-        self.company_both.openai_api_key = 'oa_key'
-        self.company_both.gemini_api_key = 'g_key'
-
-        # Compañía solo con OpenAI (la clave de gemini es None)
-        self.company_openai = MagicMock()
-        self.company_openai.short_name = 'comp_oa'
-        self.company_openai.name = 'OpenAI'
-        self.company_openai.openai_api_key = 'oa_key'
-
-        # Compañía solo con Gemini (la clave de openai es None)
-        self.company_gemini = MagicMock()
-        self.company_gemini.short_name = 'comp_g'
-        self.company_gemini.name = 'Gemini'
-
-        # Compañía sin claves
-        self.company_none = MagicMock()
-        self.company_none.short_name = 'comp_none'
-        self.company_none.name = 'None'
-        self.company_none.openai_api_key = None
-
-        patch.dict('os.environ', {'OPENAI_API_KEY': 'fb_oa', 'GEMINI_API_KEY': 'fb_g'}).start()
-
-        # Instancia "fábrica" bajo prueba
-        self.proxy_factory = LLMProxy(util=self.util_mock)
-
-    def teardown_method(self):
-        patch.stopall()
-        LLMProxy._clients_cache.clear()
-
-    def test_create_for_company(self):
-        """Prueba que el factory method crea un Proxy con ambos clientes."""
-        proxy = self.proxy_factory.create_for_company(self.company_openai)
-
-        self.mock_openai_class.assert_called_once_with(api_key='decrypted_oa_key')
-
-        assert isinstance(proxy, LLMProxy)
-        self.mock_openai_adapter_class.assert_called_once()
-        self.mock_gemini_adapter_class.assert_called_once()
-        assert proxy.openai_adapter is not None
-        assert proxy.gemini_adapter is not None
-
-    def test_create_for_company_raises_error_if_no_keys(self):
-        """Prueba que el factory method lanza una excepción si no hay ninguna clave disponible."""
-        with patch.dict('os.environ', {}, clear=True):
-            # Usar una compañía que realmente no tenga los atributos
-            company_truly_none = MagicMock()
-            company_truly_none.openai_api_key = None
-            company_truly_none.gemini_api_key = None
-
-            with pytest.raises(IAToolkitException, match="no tiene configuradas API keys"):
-                self.proxy_factory.create_for_company(company_truly_none)
-
-    def test_client_caching_works(self):
-        """Prueba que los clientes se cachean y reutilizan entre llamadas."""
-        self.proxy_factory.create_for_company(self.company_openai)
-        self.proxy_factory.create_for_company(self.company_openai)
-        self.mock_openai_class.assert_called_once_with(api_key='decrypted_oa_key')
-
-    def test_routing_to_openai_adapter(self):
-        """Prueba el enrutamiento correcto hacia el adaptador de OpenAI."""
-        self.util_mock.is_openai_model.return_value = True
-        self.util_mock.is_gemini_model.return_value = False
-
-        proxy = self.proxy_factory.create_for_company(self.company_openai)
-
-        # El método create_response no está definido en el MagicMock `proxy`,
-        # así que llamamos al método real en la instancia de fábrica para obtener una instancia real
-        work_proxy = self.proxy_factory.create_for_company(self.company_openai)
-        work_proxy.create_response(model='gpt-4', input=[])
-
-        self.mock_openai_adapter_instance.create_response.assert_called_once()
-        self.mock_gemini_adapter_instance.create_response.assert_not_called()
-
-    def test_routing_to_gemini_adapter(self):
-        """Prueba el enrutamiento correcto hacia el adaptador de OpenAI."""
-        self.util_mock.is_openai_model.return_value = False
-        self.util_mock.is_gemini_model.return_value = True
-
-        proxy = self.proxy_factory.create_for_company(self.company_openai)
-
-        # El método create_response no está definido en el MagicMock `proxy`,
-        # así que llamamos al método real en la instancia de fábrica para obtener una instancia real
-        work_proxy = self.proxy_factory.create_for_company(self.company_gemini)
-        work_proxy.create_response(model='gemini', input=[])
-
-        self.mock_gemini_adapter_instance.create_response.assert_called_once()
-        self.mock_openai_adapter_instance.create_response.assert_not_called()

tests/infra/test_mail_app.py

@@ -1,94 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import pytest
-from unittest.mock import MagicMock, patch
-from iatoolkit.common.exceptions import IAToolkitException
-from iatoolkit.infra.mail_app import MailApp
-import os
-
-class TestMailApp:
-    @classmethod
-    def setup_class(cls):
-        cls.patcher = patch.dict(os.environ, {"BREVO_API_KEY": "my-api-key"})
-        cls.patcher.start()
-
-    def setup_method(self):
-        # Crear una instancia de MailApp simulada
-        self.mail_app = MailApp()
-
-        # Mock de la API de correos transaccionales
-        self.mock_mail_api = MagicMock()
-        self.mail_app.mail_api = self.mock_mail_api
-
-    def teardown_method(self):
-        self.patcher.stop()
-
-    @patch("iatoolkit.infra.mail_app.sib_api_v3_sdk.SendSmtpEmail")
-    def test_send_email_success(self, mock_send_smtp_email):
-        """Prueba el envío exitoso del correo electrónico."""
-        # Simular una respuesta exitosa de la API
-        mock_response = MagicMock()
-        mock_response.message_id = "100"
-        self.mock_mail_api.send_transac_email.return_value = mock_response
-
-        # Llamar al método `send_email`
-        response = self.mail_app.send_email(
-            to="test@domain.com",
-            subject="Test Subject",
-            body="<p>This is a test email</p>"
-        )
-
-        # Verificaciones
-        self.mock_mail_api.send_transac_email.assert_called_once()
-        assert response == mock_response
-
-    @patch("iatoolkit.infra.mail_app.sib_api_v3_sdk.SendSmtpEmail")
-    def test_send_email_when_api_error(self, mock_send_smtp_email):
-        """Prueba el envío exitoso del correo electrónico."""
-        # Simular una respuesta exitosa de la API
-        mock_response = MagicMock()
-        self.mock_mail_api.send_transac_email.return_value = mock_response
-
-        with pytest.raises(IAToolkitException) as excinfo:
-            response = self.mail_app.send_email(
-                to="test@domain.com",
-                subject="Test Subject",
-                body="<p>This is a test email</p>"
-            )
-
-        # Verificar que la excepción es la esperada
-        assert excinfo.value.error_type == IAToolkitException.ErrorType.MAIL_ERROR
-        assert "Brevo no retornó message_id" in str(excinfo.value)
-
-
-    @patch("iatoolkit.infra.mail_app.sib_api_v3_sdk.SendSmtpEmail")
-    def test_send_email_with_error(self, mock_send_smtp_email):
-        """Prueba el manejo de errores cuando se lanza una excepción."""
-        # Simular que la API lanza una excepción
-        self.mock_mail_api.send_transac_email.side_effect = Exception("API error")
-
-        with pytest.raises(IAToolkitException) as excinfo:
-            self.mail_app.send_email(
-                to="test@domain.com",
-                subject="Test Subject",
-                body="<p>This is a test email</p>"
-            )
-
-        # Verificar que la excepción es la esperada
-        assert excinfo.value.error_type == IAToolkitException.ErrorType.MAIL_ERROR
-        assert "No se pudo enviar correo: API error" in str(excinfo.value)
-
-    def test_initial_configuration(self):
-        """Prueba la configuración inicial de MailApp."""
-        with patch("os.getenv", return_value="mocked_api_key") as mock_getenv:
-            mail_app = MailApp()
-
-            # Verificar que la configuración fue inicializada correctamente
-            assert mail_app.configuration.api_key['api-key'] == "mocked_api_key"
-            assert mail_app.sender == {'email': 'ia@iatoolkit.com', 'name': 'IA Toolkit'}
-
-            # Asegurar que os.getenv fue llamado para recuperar la clave de API
-            mock_getenv.assert_called_once_with("BREVO_API_KEY")

tests/infra/test_openai_adapter.py

@@ -1,105 +0,0 @@
-import pytest
-from unittest.mock import Mock, patch
-
-from iatoolkit.infra.llm_proxy import LLMProxy
-from iatoolkit.common.exceptions import IAToolkitException
-from iatoolkit.infra.llm_response import LLMResponse, Usage
-
-
-class TestLLMProxy:
-    """Tests para la clase LLMProxy."""
-
-    def setup_method(self):
-        """Configura el entorno de prueba para cada método."""
-        # Parcheamos las clases de los adaptadores en el módulo donde se utilizan (llm_proxy)
-        self.openai_patcher = patch('iatoolkit.infra.llm_proxy.OpenAIAdapter', autospec=True)
-        self.gemini_patcher = patch('iatoolkit.infra.llm_proxy.GeminiAdapter', autospec=True)
-
-        # Iniciamos los patchers
-        self.MockOpenAIAdapter = self.openai_patcher.start()
-        self.MockGeminiAdapter = self.gemini_patcher.start()
-
-        # Mocks para los clientes de las APIs
-        self.mock_openai_client = Mock()
-        self.mock_gemini_client = Mock()
-
-        # Instanciamos LLMProxy. Esto usará las clases de adaptadores mockeadas.
-        self.util_mock = Mock()
-        self.proxy = LLMProxy(
-            openai_client=self.mock_openai_client,
-            gemini_client=self.mock_gemini_client,
-            util=self.util_mock
-        )
-
-        # Obtenemos una referencia a las instancias mockeadas que LLMProxy crea internamente
-        self.mock_openai_adapter_instance = self.proxy.openai_adapter
-        self.mock_gemini_adapter_instance = self.proxy.gemini_adapter
-
-    def teardown_method(self):
-        """Limpia el entorno de prueba después de cada método."""
-        self.openai_patcher.stop()
-        self.gemini_patcher.stop()
-
-    def test_create_response_routes_to_openai(self):
-        """
-        Prueba que create_response enruta correctamente al adaptador de OpenAI
-        para un modelo de OpenAI.
-        """
-        model = "gpt-4"
-        input_data = [{"role": "user", "content": "Hola"}]
-        mock_usage = Usage(input_tokens=10, output_tokens=10, total_tokens=20)
-        mock_response = LLMResponse(id="resp-123", model=model, status="completed", output_text="Hola!", output=[], usage=mock_usage)
-        self.mock_openai_adapter_instance.create_response.return_value = mock_response
-        self.util_mock.is_openai_model.return_value = True
-        response = self.proxy.create_response(model=model, input=input_data)
-
-        self.mock_openai_adapter_instance.create_response.assert_called_once_with(
-            model=model,
-            input=input_data
-        )
-        self.mock_gemini_adapter_instance.create_response.assert_not_called()
-        assert response == mock_response
-
-
-    def test_create_response_with_all_params_openai(self):
-        """
-        Prueba el enrutamiento a OpenAI con todos los parámetros opcionales.
-        """
-        model = "gpt-4o"
-        input_data = [{"role": "user", "content": "Hola"}]
-        tools_data = [{"type": "function", "function": {"name": "get_weather"}}]
-        self.util_mock.is_openai_model.return_value = True
-
-        self.proxy.create_response(
-            model=model,
-            input=input_data,
-            previous_response_id="prev-123",
-            tools=tools_data,
-            text={"some": "text"},
-            reasoning={"some": "reasoning"},
-            tool_choice="specific_tool"
-        )
-
-        self.mock_openai_adapter_instance.create_response.assert_called_once_with(
-            model=model,
-            input=input_data,
-            previous_response_id="prev-123",
-            tools=tools_data,
-            text={"some": "text"},
-            reasoning={"some": "reasoning"},
-            tool_choice="specific_tool"
-        )
-        self.mock_gemini_adapter_instance.create_response.assert_not_called()
-
-    def test_create_response_raises_for_unsupported_model(self):
-        """
-        Prueba que create_response lanza una IAToolkitException para un modelo no soportado.
-        """
-        self.util_mock.is_openai_model.return_value = False
-        self.util_mock.is_gemini_model.return_value = False
-        with pytest.raises(IAToolkitException) as excinfo:
-            self.proxy.create_response(model="unsupported-model", input=[])
-
-        assert excinfo.value.error_type == IAToolkitException.ErrorType.LLM_ERROR
-        assert "Modelo no soportado: unsupported-model" in str(excinfo.value)
-

tests/infra/test_redis_session_manager_service.py

@@ -1,117 +0,0 @@
-import unittest
-import json
-from unittest.mock import patch, MagicMock
-from iatoolkit.infra.redis_session_manager import RedisSessionManager
-
-
-class TestRedisSessionManager(unittest.TestCase):
-
-    def setUp(self):
-        """
-        Configura los patches y mocks comunes para las pruebas.
-        La clave aquí es parchear _get_client para evitar cualquier llamada de red.
-        """
-        # Parchear el método que obtiene el cliente Redis
-        self.get_client_patcher = patch('iatoolkit.infra.redis_session_manager.RedisSessionManager._get_client')
-
-        # Iniciar el parche y obtener el mock del método
-        self.mock_get_client = self.get_client_patcher.start()
-
-        # Crear un mock para simular el cliente Redis real (ej. redis.Redis())
-        self.mock_redis_client = MagicMock()
-
-        # Configurar el método parcheado para que siempre devuelva nuestro cliente mockeado
-        self.mock_get_client.return_value = self.mock_redis_client
-
-    def tearDown(self):
-        patch.stopall()
-
-    def test_set(self):
-        """Prueba que el método set llama correctamente a `client.set`."""
-        RedisSessionManager.set('my_key', 'my_value', ex=3600)
-
-        # Verificar que se obtuvo el cliente
-        self.mock_get_client.assert_called_once()
-
-        # Verificar que se llamó al método `set` del cliente Redis con los argumentos correctos
-        self.mock_redis_client.set.assert_called_once_with('my_key', 'my_value', ex=3600)
-
-    def test_get_existing_key(self):
-        """Prueba que el método get devuelve el valor correcto si la clave existe."""
-        # Simular que Redis devuelve un valor
-        self.mock_redis_client.get.return_value = 'retrieved_value'
-
-        result = RedisSessionManager.get('existing_key')
-
-        self.assertEqual(result, 'retrieved_value')
-        self.mock_redis_client.get.assert_called_once_with('existing_key')
-
-    def test_get_non_existing_key(self):
-        """Prueba que get devuelve el valor por defecto (string vacío) si la clave no existe."""
-        # Simular que Redis no encuentra la clave
-        self.mock_redis_client.get.return_value = None
-
-        result = RedisSessionManager.get('non_existing_key')
-
-        # El valor por defecto en la firma del método es ""
-        self.assertEqual(result, "")
-
-    def test_remove(self):
-        """Prueba que el método remove llama a `client.delete`."""
-        RedisSessionManager.remove('key_to_delete')
-
-        self.mock_get_client.assert_called_once()
-        self.mock_redis_client.delete.assert_called_once_with('key_to_delete')
-
-    def test_set_json(self):
-        """Prueba que el método set_json serializa el diccionario y llama a `set`."""
-        test_data = {'user': 'test', 'permissions': [1, 2, 3]}
-        expected_json_string = json.dumps(test_data)
-
-        RedisSessionManager.set_json('json_key', test_data, ex=60)
-
-        # Verificar que se llamó a set con el string JSON correcto
-        self.mock_redis_client.set.assert_called_once_with('json_key', expected_json_string, ex=60)
-
-    def test_get_json_existing_key(self):
-        """Prueba que get_json obtiene un string y lo deserializa correctamente."""
-        test_data = {'user': 'test', 'id': 123}
-        json_string = json.dumps(test_data)
-        self.mock_redis_client.get.return_value = json_string
-
-        result = RedisSessionManager.get_json('json_key')
-
-        self.assertEqual(result, test_data)
-
-    def test_get_json_non_existing_key(self):
-        """Prueba que get_json devuelve el diccionario por defecto si la clave no existe."""
-        self.mock_redis_client.get.return_value = ""  # Simula una clave no encontrada
-
-        # Probar con el default por defecto ({})
-        result_default = RedisSessionManager.get_json('non_existing_key')
-        self.assertEqual(result_default, {})
-
-        # Probar con un default personalizado
-        custom_default = {"default": True}
-        result_custom = RedisSessionManager.get_json('non_existing_key', default=custom_default)
-        self.assertEqual(result_custom, custom_default)
-
-    @patch('iatoolkit.infra.redis_session_manager.logging')
-    def test_get_json_invalid_json(self, mock_logging):
-        """
-        Prueba que get_json maneja un string inválido, loguea una advertencia
-        y devuelve el valor por defecto.
-        """
-        invalid_json_string = '{"key": "value",}'  # JSON mal formado
-        self.mock_redis_client.get.return_value = invalid_json_string
-
-        result = RedisSessionManager.get_json('invalid_json_key')
-
-        self.assertEqual(result, {})
-
-        # Verificar que se registró una advertencia
-        mock_logging.warning.assert_called_once()
-        # Verificar que el mensaje de log contiene información útil
-        log_message = mock_logging.warning.call_args[0][0]
-        self.assertIn("Invalid JSON", log_message)
-        self.assertIn("invalid_json_key", log_message)

tests/repositories/__init__.py

@@ -1,5 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-