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

tests/services/test_user_session_context_service.py

@@ -1,132 +0,0 @@
-import unittest
-from unittest.mock import patch
-from iatoolkit.services.user_session_context_service import UserSessionContextService
-
-
-class TestUserSessionContextService(unittest.TestCase):
-
-    def setUp(self):
-        """Configura el servicio y los mocks antes de cada test."""
-        self.service = UserSessionContextService()
-        self.company_short_name = "test_company"
-        self.user_identifier = "test_user"
-
-        # Definir las claves esperadas para reutilizarlas en los tests
-        self.history_key = f"llm_history:{self.company_short_name}/{self.user_identifier}"
-        self.data_key = f"user_data:{self.company_short_name}/{self.user_identifier}"
-
-        # Patchear la dependencia RedisSessionManager para aislar el servicio
-        self.redis_patcher = patch("iatoolkit.services.user_session_context_service.RedisSessionManager")
-        self.mock_redis_manager = self.redis_patcher.start()
-
-    def tearDown(self):
-        """Limpia los patches después de cada test."""
-        patch.stopall()
-
-    def test_save_last_response_id(self):
-        """Prueba que se guarda correctamente el ID de la última respuesta."""
-        response_id = "resp_xyz"
-        self.service.save_last_response_id(self.company_short_name, self.user_identifier, response_id)
-        # Verificar que se llamó a Redis con la clave y valor correctos
-        self.mock_redis_manager.set.assert_called_once_with(self.history_key, response_id)
-
-    def test_get_last_response_id(self):
-        """Prueba que se obtiene correctamente el ID de la última respuesta."""
-        self.mock_redis_manager.get.return_value = "resp_abc"
-        result = self.service.get_last_response_id(self.company_short_name, self.user_identifier)
-
-        # Verificar que se llamó a Redis con la clave y el default correctos
-        self.mock_redis_manager.get.assert_called_once_with(self.history_key, '')
-        self.assertEqual(result, "resp_abc")
-
-    def test_save_user_session_data(self):
-        """Prueba que los datos de sesión del usuario se guardan como JSON."""
-        data = {"role": "admin", "theme": "dark"}
-        self.service.save_user_session_data(self.company_short_name, self.user_identifier, data)
-        # Verificar que se llamó a set_json con la clave y los datos correctos
-        self.mock_redis_manager.set_json.assert_called_once_with(self.data_key, data)
-
-    def test_get_user_session_data(self):
-        """Prueba que los datos de sesión del usuario se recuperan correctamente."""
-        expected_data = {"role": "admin", "theme": "dark"}
-        self.mock_redis_manager.get_json.return_value = expected_data
-
-        result = self.service.get_user_session_data(self.company_short_name, self.user_identifier)
-
-        # Verificar que se llamó a get_json con la clave y el default correctos
-        self.mock_redis_manager.get_json.assert_called_once_with(self.data_key, {})
-        self.assertEqual(result, expected_data)
-
-    def test_clear_llm_history(self):
-        """Prueba que el historial del LLM se limpia correctamente."""
-        self.service.clear_llm_history(self.company_short_name, self.user_identifier)
-        # Verificar que se llamó a remove con la clave del historial
-        self.mock_redis_manager.remove.assert_called_once_with(self.history_key)
-
-    def test_clear_user_session_data(self):
-        """Prueba que los datos de sesión del usuario se limpian correctamente."""
-        self.service.clear_user_session_data(self.company_short_name, self.user_identifier)
-        # Verificar que se llamó a remove con la clave de datos de usuario
-        self.mock_redis_manager.remove.assert_called_once_with(self.data_key)
-
-    def test_clear_all_context(self):
-        """Prueba que se limpian ambos contextos (historial y datos de usuario)."""
-        self.service.clear_all_context(self.company_short_name, self.user_identifier)
-
-        # Verificar que se llamó a remove para ambas claves
-        self.mock_redis_manager.remove.assert_any_call(self.history_key)
-        self.mock_redis_manager.remove.assert_any_call(self.data_key)
-        # Asegurarse de que se hicieron exactamente dos llamadas a remove
-        self.assertEqual(self.mock_redis_manager.remove.call_count, 2)
-
-    def test_methods_do_nothing_with_none_user_identifier(self):
-        """
-        Prueba que ningún método interactúa con Redis si el user_identifier es None.
-        """
-        user_id = None
-
-        # Probar métodos de escritura
-        self.service.save_last_response_id(self.company_short_name, user_id, "id_1")
-        self.service.save_user_session_data(self.company_short_name, user_id, {"data": "value"})
-        self.service.clear_all_context(self.company_short_name, user_id)
-
-        # Probar métodos de lectura
-        get_id_result = self.service.get_last_response_id(self.company_short_name, user_id)
-        get_data_result = self.service.get_user_session_data(self.company_short_name, user_id)
-
-        # Verificar que NUNCA se llamó a Redis
-        self.mock_redis_manager.set.assert_not_called()
-        self.mock_redis_manager.get.assert_not_called()
-        self.mock_redis_manager.set_json.assert_not_called()
-        self.mock_redis_manager.get_json.assert_not_called()
-        self.mock_redis_manager.remove.assert_not_called()
-
-        # Verificar que los métodos de lectura devuelven valores seguros/por defecto
-        self.assertIsNone(get_id_result)
-        self.assertEqual(get_data_result, {})
-
-    def test_methods_do_nothing_with_empty_user_identifier(self):
-        """
-        Prueba que ningún método interactúa con Redis si el user_identifier es una cadena vacía o espacios.
-        """
-        for user_id in ["", "   "]:
-            # Probar métodos de escritura
-            self.service.save_last_response_id(self.company_short_name, user_id, "id_1")
-            self.service.save_user_session_data(self.company_short_name, user_id, {"data": "value"})
-            self.service.clear_all_context(self.company_short_name, user_id)
-
-            # Probar métodos de lectura
-            get_id_result = self.service.get_last_response_id(self.company_short_name, user_id)
-            get_data_result = self.service.get_user_session_data(self.company_short_name, user_id)
-
-            # Verificar que los métodos de lectura devuelven valores seguros/por defecto
-            self.assertIsNone(get_id_result)
-            self.assertEqual(get_data_result, {})
-
-        # Al final del bucle, verificar que NUNCA se llamó a Redis
-        self.mock_redis_manager.set.assert_not_called()
-        self.mock_redis_manager.get.assert_not_called()
-        self.mock_redis_manager.set_json.assert_not_called()
-        self.mock_redis_manager.get_json.assert_not_called()
-        self.mock_redis_manager.remove.assert_not_called()
-

tests/views/__init__.py

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

tests/views/test_change_password_view.py

@@ -1,191 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import pytest
-from flask import Flask
-from unittest.mock import MagicMock, patch
-from iatoolkit.services.profile_service import ProfileService
-from iatoolkit.views.change_password_view import ChangePasswordView
-from itsdangerous import SignatureExpired
-import os
-from iatoolkit.repositories.models import Company
-
-
-
-class TestChangePasswordView:
-    @classmethod
-    def setup_class(cls):
-        cls.patcher = patch.dict(os.environ, {"PASS_RESET_KEY": "mocked_reset_key"})
-        cls.patcher.start()
-
-    @classmethod
-    def teardown_class(cls):
-        cls.patcher.stop()
-
-    @staticmethod
-    def create_app():
-        """Configura la aplicación Flask para pruebas."""
-        app = Flask(__name__)
-        app.testing = True
-        return app
-
-    @pytest.fixture(autouse=True)
-    def setup(self):
-        """Configura el cliente y los mocks antes de cada test."""
-        self.app = self.create_app()
-        self.client = self.app.test_client()
-        self.profile_service = MagicMock(spec=ProfileService)
-        self.test_company = Company(
-            id=1,
-            name="Empresa de Prueba",
-            short_name="test_company",
-            logo_file="test_logo.png"
-        )
-        self.profile_service.get_company_by_short_name.return_value = self.test_company
-
-        # Registrar la vista
-        view = ChangePasswordView.as_view("change_password", profile_service=self.profile_service)
-        self.app.add_url_rule("/<company_short_name>/change_password/<token>", view_func=view, methods=["GET", "POST"])
-
-
-    @patch("iatoolkit.views.change_password_view.render_template")
-    def test_get_and_post_invalid_company(self, mock_render):
-        self.profile_service.get_company_by_short_name.return_value = None
-        response = self.client.get("/test_company/change_password/valid_token")
-        assert response.status_code == 404
-
-        response = self.client.post("/test_company/change_password/valid_token",
-                                    data={
-                                        "temp_code": "123456",
-                                        "new_password": "password123",
-                                        "confirm_password": "password456"
-                                    },
-                                    content_type="application/x-www-form-urlencoded")
-
-        assert response.status_code == 404
-
-    @patch("iatoolkit.views.change_password_view.render_template")
-    def test_get_with_expired_token(self, mock_render_template):
-        """Prueba GET con un token expirado."""
-        # Configura el serializer para que lance una excepción SignatureExpired
-        with patch("iatoolkit.views.change_password_view.URLSafeTimedSerializer") as mock_serializer_class:
-            mock_serializer = mock_serializer_class.return_value
-            mock_serializer.loads.side_effect = SignatureExpired('error')
-
-            mock_render_template.return_value = "<html><body><h1>Forgot Password</h1></body></html>"
-            response = self.client.get("/test_company/change_password/expired_token")
-
-            mock_render_template.assert_called_once_with(
-                "forgot_password.html",
-                alert_message="El enlace de cambio de contraseña ha expirado. Por favor, solicita uno nuevo."
-            )
-            assert response.status_code == 200
-
-    @patch("iatoolkit.views.change_password_view.render_template")
-    def test_get_with_valid_token(self, mock_render_template):
-        """Prueba GET con un token válido."""
-        with patch("iatoolkit.views.change_password_view.URLSafeTimedSerializer") as mock_serializer_class:
-            mock_serializer = mock_serializer_class.return_value
-            mock_serializer.loads.return_value = "valid@email.com"
-
-            mock_render_template.return_value = "<html><body><h1>Change Password</h1></body></html>"
-            response = self.client.get("/test_company/change_password/valid_token")
-
-            mock_render_template.assert_called_once_with(
-                "change_password.html",
-                company=self.test_company,
-                company_short_name='test_company',
-                token="valid_token",
-                email="valid@email.com"
-            )
-            assert response.status_code == 200
-
-    @patch("iatoolkit.views.change_password_view.render_template")
-    @patch("iatoolkit.views.change_password_view.URLSafeTimedSerializer")
-    def test_post_with_expired_token(self, mock_serializer, mock_render_template):
-        # Configura el serializer para que lance una excepción SignatureExpired
-        mock_serializer.return_value.loads.side_effect = SignatureExpired('error')
-
-        mock_render_template.return_value = "<html><body><h1>Forgot Password</h1></body></html>"
-        response = self.client.post("/test_company/change_password/valid_token",
-                                        data={
-                                            "temp_code": "123456",
-                                            "new_password": "password123",
-                                            "confirm_password": "password456"
-                                        },
-                                        content_type="application/x-www-form-urlencoded")
-
-        mock_render_template.assert_called_once_with(
-            "forgot_password.html",
-            company=self.test_company,
-            company_short_name='test_company',
-            alert_message="El enlace de cambio de contraseña ha expirado. Por favor, solicita uno nuevo."
-        )
-        assert response.status_code == 200
-
-    @patch("iatoolkit.views.change_password_view.render_template")
-    @patch("iatoolkit.views.change_password_view.URLSafeTimedSerializer")
-    def test_post_with_error(self, mock_serializer, mock_render_template):
-        mock_serializer.return_value.return_value = "valid@email.com"
-        mock_render_template.return_value = "<html><body></body></html>"
-        self.profile_service.change_password.return_value = \
-            {'error': 'password missmatch'}
-        response = self.client.post("/test_company/change_password/valid_token",
-                                        data={
-                                            "temp_code": "123456",
-                                            "new_password": "password123",
-                                            "confirm_password": "password456"
-                                        },
-                                        content_type="application/x-www-form-urlencoded")
-
-        mock_render_template.assert_called_once_with(
-                "change_password.html",
-            company=self.test_company,
-            company_short_name='test_company',
-                form_data={"temp_code": "123456", "new_password": "password123", "confirm_password": "password456"},
-                alert_message='password missmatch',
-                token='valid_token'
-            )
-        assert response.status_code == 400
-
-    @patch("iatoolkit.views.change_password_view.render_template")
-    @patch("iatoolkit.views.change_password_view.URLSafeTimedSerializer")
-    def test_post_ok(self, mock_serializer, mock_render_template):
-        mock_serializer.return_value.return_value = "valid@email.com"
-        mock_render_template.return_value = "<html><body></body></html>"
-        self.profile_service.change_password.return_value = \
-            {'message': 'password changed'}
-
-        response = self.client.post("/test_company/change_password/valid_token",
-                                    data={
-                                        "temp_code": "123456",
-                                        "new_password": "password123",
-                                        "confirm_password": "password456"
-                                    },
-                                    content_type="application/x-www-form-urlencoded")
-
-        mock_render_template.assert_called_once_with(
-            "login.html",
-            company=self.test_company,
-            company_short_name='test_company',
-            alert_icon='success',
-            alert_message="Tu contraseña ha sido restablecida exitosamente. Ahora puedes iniciar sesión."
-        )
-        assert response.status_code == 200
-
-    @patch("iatoolkit.views.change_password_view.render_template")
-    @patch("iatoolkit.views.change_password_view.URLSafeTimedSerializer")
-    def test_post_unexpected_error(self, mock_serializer, mock_render_template):
-        mock_serializer.return_value.loads.return_value ='123'
-        self.profile_service.change_password.side_effect = Exception('an error')
-        response = self.client.post("/test_company/change_password/valid_token",
-                                    data={
-                                        "temp_code": "123456",
-                                        "new_password": "password123",
-                                        "confirm_password": "password456"
-                                    },
-                                    content_type="application/x-www-form-urlencoded")
-
-        assert response.status_code == 500

tests/views/test_chat_token_request_view.py

@@ -1,188 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import pytest
-from flask import Flask
-from unittest.mock import MagicMock
-from iatoolkit.views.chat_token_request_view import ChatTokenRequestView
-from iatoolkit.services.jwt_service import JWTService
-from iatoolkit.repositories.profile_repo import ProfileRepo
-
-# --- Constantes de Prueba ---
-VALID_API_KEY_VALUE = "test-api-key-123"
-MOCK_AUTH_COMPANY_ID = 100
-MOCK_AUTH_COMPANY_SHORT_NAME = "authcomp"
-MOCK_EXTERNAL_USER_ID = "ext-user-456"
-GENERATED_TEST_JWT = "test.jwt.token.string"
-JWT_EXPIRATION_CONFIG_VALUE = 1800  # 30 minutos para test
-
-
-class TestChatTokenRequestView:
-    @staticmethod
-    def create_app():
-        """Configura la aplicación Flask para pruebas."""
-        app = Flask(__name__)
-        app.testing = True
-        app.config['JWT_EXPIRATION_SECONDS_CHAT'] = JWT_EXPIRATION_CONFIG_VALUE
-        # Aseguramos que current_app.config esté disponible en el init de la vista
-        # app.app_context().push() # No es necesario aquí si la vista se instancia dentro del contexto en setup
-        return app
-
-    @pytest.fixture(autouse=True)
-    def setup(self):
-        self.app = self.create_app()
-        # Es importante que la vista se registre y se cree el cliente de prueba
-        # dentro de un contexto de aplicación para que current_app esté disponible.
-        with self.app.app_context():
-            self.profile_repo = MagicMock(spec=ProfileRepo)
-            self.jwt_service = MagicMock(spec=JWTService)
-
-            # register the view
-            view_func = ChatTokenRequestView.as_view(
-                'chat-token',  # Nombre del endpoint para el test
-                profile_repo=self.profile_repo,
-                jwt_service=self.jwt_service
-            )
-            self.app.add_url_rule('/auth/chat_token', view_func=view_func, methods=['POST'])
-
-        self.client = self.app.test_client()
-
-    def test_post_no_api_key_header(self):
-        response = self.client.post('/auth/chat_token', json={
-            "company_short_name": MOCK_AUTH_COMPANY_SHORT_NAME,
-            "external_user_id": MOCK_EXTERNAL_USER_ID
-        })
-        assert response.status_code == 401
-        assert response.json == {"error": "API Key faltante o mal formada en el header Authorization"}
-
-    def test_post_malformed_api_key_header(self):
-        """Prueba POST con header de Authorization mal formado."""
-        response = self.client.post('/auth/chat_token',
-                                    headers={"Authorization": "NotBearerKey"},
-                                    json={
-                                        "company_short_name": MOCK_AUTH_COMPANY_SHORT_NAME,
-                                        "external_user_id": MOCK_EXTERNAL_USER_ID
-                                    })
-        assert response.status_code == 401
-        assert response.json == {"error": "API Key faltante o mal formada en el header Authorization"}
-
-    def test_post_invalid_or_inactive_api_key(self):
-        """Prueba POST con una API Key inválida o inactiva."""
-        self.profile_repo.get_active_api_key_entry.return_value = None
-        response = self.client.post('/auth/chat_token', headers={"Authorization": f"Bearer {VALID_API_KEY_VALUE}"},
-                                    json={
-                                        "company_short_name": MOCK_AUTH_COMPANY_SHORT_NAME,
-                                        "external_user_id": MOCK_EXTERNAL_USER_ID
-                                    })
-        assert response.status_code == 401
-        assert response.json == {"error": "API Key inválida o inactiva"}
-        self.profile_repo.get_active_api_key_entry.assert_called_once_with(VALID_API_KEY_VALUE)
-
-    def test_post_api_key_without_company_association(self):
-        """Prueba POST con API Key válida pero sin compañía asociada (error de datos)."""
-        mock_api_key_entry = MagicMock()
-        mock_api_key_entry.company = None
-        mock_api_key_entry.company_id = None
-        self.profile_repo.get_active_api_key_entry.return_value = mock_api_key_entry
-
-        response = self.client.post('/auth/chat_token', headers={"Authorization": f"Bearer {VALID_API_KEY_VALUE}"},
-                                    json={
-                                        "company_short_name": MOCK_AUTH_COMPANY_SHORT_NAME,
-                                        "external_user_id": MOCK_EXTERNAL_USER_ID
-                                    })
-        assert response.status_code == 500
-        assert response.json == {"error": "Error interno del servidor al verificar API Key"}
-
-    def test_post_api_key_validation_internal_exception(self):
-        """Prueba POST donde la validación de API Key lanza una excepción."""
-        self.profile_repo.get_active_api_key_entry.side_effect = Exception("Database connection error")
-        response = self.client.post('/auth/chat_token', headers={"Authorization": f"Bearer {VALID_API_KEY_VALUE}"},
-                                    json={
-                                        "company_short_name": MOCK_AUTH_COMPANY_SHORT_NAME,
-                                        "external_user_id": MOCK_EXTERNAL_USER_ID
-                                    })
-        assert response.status_code == 500
-        assert response.json == {"error": "Error interno del servidor al validar API Key"}
-
-    def _setup_successful_auth(self):
-        """Helper para configurar una autenticación de API Key exitosa."""
-        mock_company_obj = MagicMock()
-        mock_company_obj.short_name = MOCK_AUTH_COMPANY_SHORT_NAME
-
-        mock_api_key_entry_obj = MagicMock()
-        mock_api_key_entry_obj.company_id = MOCK_AUTH_COMPANY_ID
-        mock_api_key_entry_obj.company = mock_company_obj
-        self.profile_repo.get_active_api_key_entry.return_value = mock_api_key_entry_obj
-
-    def test_post_missing_json_body(self):
-        """Prueba POST con header de autenticación válido pero sin cuerpo JSON."""
-        self._setup_successful_auth()
-        response = self.client.post('/auth/chat_token',
-                                    headers={"Authorization": f"Bearer {VALID_API_KEY_VALUE}"},
-                                    json={},
-                                    content_type="application/json")
-        assert response.status_code == 400
-        assert response.json == {"error": "Cuerpo de la solicitud JSON faltante"}
-
-    @pytest.mark.parametrize("payload", [
-        {"external_user_id": MOCK_EXTERNAL_USER_ID},  # Falta company_short_name
-        {"company_short_name": MOCK_AUTH_COMPANY_SHORT_NAME},  # Falta external_user_id
-    ])
-    def test_post_missing_fields_in_json_payload(self, payload):
-        """Prueba POST con campos faltantes en el payload JSON."""
-        self._setup_successful_auth()
-        response = self.client.post('/auth/chat_token',
-                                    headers={"Authorization": f"Bearer {VALID_API_KEY_VALUE}"},
-                                    json=payload)
-        assert response.status_code == 401
-        assert response.json['error'] == "Faltan 'company_short_name' o 'external_user_id' en el cuerpo de la solicitud"
-
-    def test_post_api_key_company_mismatch_with_payload(self):
-        """Prueba POST donde la compañía de la API Key no coincide con la del payload."""
-        self._setup_successful_auth()  # API Key es de MOCK_AUTH_COMPANY_SHORT_NAME
-
-        mismatched_company_short_name = "othercomp"
-        response = self.client.post('/auth/chat_token',
-                                    headers={"Authorization": f"Bearer {VALID_API_KEY_VALUE}"},
-                                    json={
-                                        "company_short_name": mismatched_company_short_name,
-                                        "external_user_id": MOCK_EXTERNAL_USER_ID
-                                    })
-        assert response.status_code == 403
-        assert response.json == {
-            "error": f"API Key no autorizada para generar tokens para la compañía '{mismatched_company_short_name}'"}
-
-    def test_post_successful_token_generation(self):
-        """Prueba una generación de token exitosa."""
-        self._setup_successful_auth()
-        self.jwt_service.generate_chat_jwt.return_value = GENERATED_TEST_JWT
-
-        response = self.client.post('/auth/chat_token', headers={"Authorization": f"Bearer {VALID_API_KEY_VALUE}"},
-                                    json={
-                                        "company_short_name": MOCK_AUTH_COMPANY_SHORT_NAME,
-                                        "external_user_id": MOCK_EXTERNAL_USER_ID
-                                    })
-
-        assert response.status_code == 200
-        assert response.json == {"chat_jwt": GENERATED_TEST_JWT}
-        self.jwt_service.generate_chat_jwt.assert_called_once_with(
-            company_id=MOCK_AUTH_COMPANY_ID,
-            company_short_name=MOCK_AUTH_COMPANY_SHORT_NAME,
-            external_user_id=MOCK_EXTERNAL_USER_ID,
-            expires_delta_seconds=JWT_EXPIRATION_CONFIG_VALUE
-        )
-
-    def test_post_jwt_service_fails_to_generate_token(self):
-        """Prueba el caso donde JWTService no puede generar un token."""
-        self._setup_successful_auth()
-        self.jwt_service.generate_chat_jwt.return_value = None  # Simula fallo en la generación
-
-        response = self.client.post('/auth/chat_token', headers={"Authorization": f"Bearer {VALID_API_KEY_VALUE}"},
-                                    json={
-                                        "company_short_name": MOCK_AUTH_COMPANY_SHORT_NAME,
-                                        "external_user_id": MOCK_EXTERNAL_USER_ID
-                                    })
-        assert response.status_code == 500
-        assert response.json == {"error": "No se pudo generar el token de chat"}

tests/views/test_chat_view.py

@@ -1,98 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import pytest
-from flask import Flask
-from unittest.mock import MagicMock, patch
-from iatoolkit.services.profile_service import ProfileService
-from iatoolkit.repositories.models import Company
-from iatoolkit.views.chat_view import ChatView
-from iatoolkit.common.session_manager import SessionManager
-from datetime import datetime, timezone
-from iatoolkit.common.auth import IAuthentication
-from iatoolkit.services.prompt_manager_service import PromptService
-
-
-class TestChatView:
-    @staticmethod
-    def create_app():
-        """Configura la aplicación Flask para pruebas."""
-        app = Flask(__name__)
-        app.testing = True
-        return app
-
-    @pytest.fixture(autouse=True)
-    def setup(self):
-        """Configura el cliente y los mocks antes de cada test."""
-        self.app = self.create_app()
-        self.client = self.app.test_client()
-        self.profile_service = MagicMock(spec=ProfileService)
-        self.iauthentication = MagicMock(spec=IAuthentication)
-        self.prompt_service = MagicMock(spec=PromptService)
-
-        self.iauthentication.verify.return_value = {
-            'success': True,
-            'company_id': 101,
-            'external_user_id': 'test_user_id'
-        }
-
-        @self.app.route('/login')
-        def login():
-            return "Login Page", 200
-
-        self.test_company = Company(
-            id=1,
-            name="Empresa de Prueba",
-            short_name="test_company",
-            logo_file="test_logo.png"
-        )
-        self.profile_service.get_company_by_short_name.return_value = self.test_company
-
-        # Registrar la vista
-        view = ChatView.as_view("chat",
-                                profile_service=self.profile_service,
-                                iauthentication=self.iauthentication,
-                                prompt_service=self.prompt_service,
-                                )
-        self.app.add_url_rule("/<company_short_name>/chat", view_func=view, methods=["GET"])
-
-        # Mock values
-        mock_values = {
-            'user': {'id': 1, 'username': 'test_user'},
-            'user_id': 1,
-            'company_id': 100,
-            'company_short_name': 'test_company',
-            'last_activity': datetime.now(timezone.utc).timestamp()
-        }
-
-        # Mockear SessionManager.get
-        mock_session_manager = MagicMock(spec=SessionManager)  # <- Mock de la clase
-        mock_session_manager.get.side_effect = lambda key, default=None: mock_values.get(key, default)
-
-        with patch('iatoolkit.common.auth.SessionManager', new=mock_session_manager):  # <-  Aplicar el mock
-            with self.app.test_request_context():  # Necesario para Flask
-                yield
-
-    def test_get_missing_auth(self):
-        self.iauthentication.verify.return_value = {'error_message': 'error in authentication'}
-        response = self.client.get("/test_company/chat")
-        assert response.status_code == 401
-
-    @patch("iatoolkit.views.chat_view.render_template")
-    def test_get_invalid_company(self, mock_render):
-        self.profile_service.get_company_by_short_name.return_value = None
-        response = self.client.get("/test_company/chat")
-        assert response.status_code == 404
-
-
-    @patch("iatoolkit.views.chat_view.render_template")
-    def test_get_chat(self, mock_render_template):
-        mock_render_template.return_value = "<html><body><h1>Home Page</h1></body></html>"
-        response = self.client.get("/test_company/chat")
-
-        # Asegúrate de que se llame a render_template correctamente
-        mock_render_template.assert_called_once()
-        assert response.status_code == 200
-        assert b"<h1>Home Page</h1>" in response.data