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

tests/services/test_jwt_service.py

@@ -1,255 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import pytest
-import time
-import jwt  # Necesario para crear tokens con payloads específicos para casos de error
-from flask import Flask
-from iatoolkit.services.jwt_service import JWTService # Asegúrate que la ruta de importación sea correcta
-from unittest.mock import patch
-
-
-# Datos comunes para los tests, pueden ser definidos a nivel de módulo o clase
-COMPANY_ID = 1
-COMPANY_SHORT_NAME = "testcomp"
-EXTERNAL_USER_ID = "user123"
-EXPIRES_DELTA_SECONDS = 300  # 5 minutos
-TEST_SECRET_KEY = 'test-super-secret-key'
-TEST_ALGORITHM = 'HS256'
-
-@pytest.fixture
-def app():
-    """Fixture para crear una instancia de la aplicación Flask para tests."""
-    flask_app = Flask(__name__)
-    flask_app.config['JWT_SECRET_KEY'] = TEST_SECRET_KEY
-    flask_app.config['JWT_ALGORITHM'] = TEST_ALGORITHM
-    return flask_app
-
-@pytest.fixture
-def jwt_service(app):
-    """Fixture para crear una instancia de JWTService."""
-    return JWTService(app)
-
-class TestJWTService:
-
-    def test_initialization_missing_config(self):
-        """Prueba que JWTService levante RuntimeError si falta configuración."""
-        app_sin_config_key = Flask(__name__)
-        app_sin_config_key.config['JWT_ALGORITHM'] = TEST_ALGORITHM  # Falta JWT_SECRET_KEY
-        with pytest.raises(RuntimeError, match="Configuración JWT esencial faltante: 'JWT_SECRET_KEY'"):
-            JWTService(app_sin_config_key)
-
-        app_sin_config_algo = Flask(__name__)
-        app_sin_config_algo.config['JWT_SECRET_KEY'] = TEST_SECRET_KEY  # Falta JWT_ALGORITHM
-        with pytest.raises(RuntimeError, match="Configuración JWT esencial faltante: 'JWT_ALGORITHM'"):
-            JWTService(app_sin_config_algo)
-
-    def test_generate_chat_jwt_success(self, jwt_service, app):
-        """Prueba la generación exitosa de un JWT."""
-        token = jwt_service.generate_chat_jwt(
-            COMPANY_ID,
-            COMPANY_SHORT_NAME,
-            EXTERNAL_USER_ID,
-            EXPIRES_DELTA_SECONDS
-        )
-        assert token is not None
-        assert isinstance(token, str)
-
-        # Decodificar para verificar el payload
-        payload = jwt.decode(
-            token,
-            app.config['JWT_SECRET_KEY'],
-            algorithms=[app.config['JWT_ALGORITHM']]
-        )
-        assert payload['company_id'] == COMPANY_ID
-        assert payload['company_short_name'] == COMPANY_SHORT_NAME
-        assert payload['external_user_id'] == EXTERNAL_USER_ID
-        assert payload['type'] == 'chat_session'
-        assert 'exp' in payload
-        assert 'iat' in payload
-        # Usar pytest.approx para comparar timestamps con una tolerancia
-        assert payload['exp'] == pytest.approx(time.time() + EXPIRES_DELTA_SECONDS, abs=5)
-
-    @patch('jwt.encode')
-    def test_generate_chat_jwt_encode_exception(self, mock_jwt_encode, jwt_service):
-        mock_jwt_encode.side_effect = Exception("JWT Encode Error")
-        token = jwt_service.generate_chat_jwt(
-            COMPANY_ID,
-            COMPANY_SHORT_NAME,
-            EXTERNAL_USER_ID,
-            EXPIRES_DELTA_SECONDS
-        )
-        assert token is None
-
-    def test_validate_chat_jwt_success(self, jwt_service):
-        """Prueba la validación exitosa de un JWT."""
-        token = jwt_service.generate_chat_jwt(
-            COMPANY_ID,
-            COMPANY_SHORT_NAME,
-            EXTERNAL_USER_ID,
-            EXPIRES_DELTA_SECONDS
-        )
-        payload = jwt_service.validate_chat_jwt(token, COMPANY_SHORT_NAME)
-        assert payload is not None
-        assert payload['company_id'] == COMPANY_ID
-        assert payload['company_short_name'] == COMPANY_SHORT_NAME
-        assert payload['external_user_id'] == EXTERNAL_USER_ID
-        assert payload['type'] == 'chat_session'
-
-    def test_validate_chat_jwt_expired(self, jwt_service):
-        """Prueba la validación de un JWT expirado."""
-        token = jwt_service.generate_chat_jwt(
-            COMPANY_ID,
-            COMPANY_SHORT_NAME,
-            EXTERNAL_USER_ID,
-            expires_delta_seconds=1  # Expira en 1 segundo
-        )
-        time.sleep(2)  # Esperar a que expire
-        payload = jwt_service.validate_chat_jwt(token, COMPANY_SHORT_NAME)
-        assert payload is None
-
-    def test_validate_chat_jwt_invalid_signature(self, jwt_service, app):
-        """Prueba la validación de un JWT con firma inválida."""
-        payload_data = {
-            'company_id': COMPANY_ID,
-            'company_short_name': COMPANY_SHORT_NAME,
-            'external_user_id': EXTERNAL_USER_ID,
-            'exp': time.time() + EXPIRES_DELTA_SECONDS,
-            'iat': time.time(),
-            'type': 'chat_session'
-        }
-        # Generar token con una clave secreta diferente
-        invalid_token = jwt.encode(
-            payload_data,
-            'another-wrong-secret-key',
-            algorithm=app.config['JWT_ALGORITHM']
-        )
-        payload = jwt_service.validate_chat_jwt(invalid_token, COMPANY_SHORT_NAME)
-        assert payload is None
-
-    def test_validate_chat_jwt_wrong_company_short_name(self, jwt_service):
-        """Prueba la validación con un company_short_name incorrecto."""
-        token = jwt_service.generate_chat_jwt(
-            COMPANY_ID,
-            COMPANY_SHORT_NAME,  # "testcomp"
-            EXTERNAL_USER_ID,
-            EXPIRES_DELTA_SECONDS
-        )
-        payload = jwt_service.validate_chat_jwt(token, "anothercomp")
-        assert payload is None
-
-    def test_validate_chat_jwt_incorrect_type(self, jwt_service, app):
-        """Prueba la validación de un JWT con un tipo incorrecto."""
-        payload_data = {
-            'company_id': COMPANY_ID,
-            'company_short_name': COMPANY_SHORT_NAME,
-            'external_user_id': EXTERNAL_USER_ID,
-            'exp': time.time() + EXPIRES_DELTA_SECONDS,
-            'iat': time.time(),
-            'type': 'not_chat_session'  # Tipo incorrecto
-        }
-        token_wrong_type = jwt.encode(
-            payload_data,
-            app.config['JWT_SECRET_KEY'],
-            algorithm=app.config['JWT_ALGORITHM']
-        )
-        payload = jwt_service.validate_chat_jwt(token_wrong_type, COMPANY_SHORT_NAME)
-        assert payload is None
-
-    def test_validate_chat_jwt_missing_external_user_id(self, jwt_service, app):
-        """Prueba la validación de un JWT sin external_user_id."""
-        payload_data_missing = {
-            'company_id': COMPANY_ID,
-            'company_short_name': COMPANY_SHORT_NAME,
-            # 'external_user_id': EXTERNAL_USER_ID, # Ausente
-            'exp': time.time() + EXPIRES_DELTA_SECONDS,
-            'iat': time.time(),
-            'type': 'chat_session'
-        }
-        token_missing_field = jwt.encode(
-            payload_data_missing,
-            app.config['JWT_SECRET_KEY'],
-            algorithm=app.config['JWT_ALGORITHM']
-        )
-        payload = jwt_service.validate_chat_jwt(token_missing_field, COMPANY_SHORT_NAME)
-        assert payload is None
-
-        payload_data_empty_user_id = {
-            'company_id': COMPANY_ID,
-            'company_short_name': COMPANY_SHORT_NAME,
-            'external_user_id': "",  # Vacío
-            'exp': time.time() + EXPIRES_DELTA_SECONDS,
-            'iat': time.time(),
-            'type': 'chat_session'
-        }
-        token_empty_user_id = jwt.encode(
-            payload_data_empty_user_id,
-            app.config['JWT_SECRET_KEY'],
-            algorithm=app.config['JWT_ALGORITHM']
-        )
-        payload = jwt_service.validate_chat_jwt(token_empty_user_id, COMPANY_SHORT_NAME)
-        assert payload is None
-
-    def test_validate_chat_jwt_missing_company_id(self, jwt_service, app):
-        """Prueba la validación de un JWT sin company_id."""
-        payload_data = {
-            # 'company_id': COMPANY_ID, # Ausente
-            'company_short_name': COMPANY_SHORT_NAME,
-            'external_user_id': EXTERNAL_USER_ID,
-            'exp': time.time() + EXPIRES_DELTA_SECONDS,
-            'iat': time.time(),
-            'type': 'chat_session'
-        }
-        token_missing_field = jwt.encode(
-            payload_data,
-            app.config['JWT_SECRET_KEY'],
-            algorithm=app.config['JWT_ALGORITHM']
-        )
-        payload = jwt_service.validate_chat_jwt(token_missing_field, COMPANY_SHORT_NAME)
-        assert payload is None
-
-    def test_validate_chat_jwt_invalid_company_id_type(self, jwt_service, app):
-        """Prueba la validación de un JWT con company_id de tipo incorrecto."""
-        payload_data = {
-            'company_id': "not_an_int",  # Tipo incorrecto
-            'company_short_name': COMPANY_SHORT_NAME,
-            'external_user_id': EXTERNAL_USER_ID,
-            'exp': time.time() + EXPIRES_DELTA_SECONDS,
-            'iat': time.time(),
-            'type': 'chat_session'
-        }
-        token_invalid_type = jwt.encode(
-            payload_data,
-            app.config['JWT_SECRET_KEY'],
-            algorithm=app.config['JWT_ALGORITHM']
-        )
-        payload = jwt_service.validate_chat_jwt(token_invalid_type, COMPANY_SHORT_NAME)
-        assert payload is None
-
-    def test_validate_chat_jwt_empty_token(self, jwt_service):
-        """Prueba la validación con un token vacío."""
-        payload = jwt_service.validate_chat_jwt("", COMPANY_SHORT_NAME)
-        assert payload is None
-
-    def test_validate_chat_jwt_none_token(self, jwt_service):
-        """Prueba la validación con un token None."""
-        payload = jwt_service.validate_chat_jwt(None, COMPANY_SHORT_NAME)
-        assert payload is None
-
-    @patch('jwt.decode')
-    def test_validate_chat_jwt_decode_exception(self, mock_jwt_decode, jwt_service):
-        """Prueba que validate_chat_jwt maneje excepciones generales de jwt.decode (no InvalidTokenError)."""
-        mock_jwt_decode.side_effect = Exception("JWT Decode Error")
-        # Necesitamos un token, aunque será el mock el que falle.
-        # Podríamos pasar cualquier string, pero generar uno real es más consistente.
-        token = jwt_service.generate_chat_jwt(
-            COMPANY_ID,
-            COMPANY_SHORT_NAME,
-            EXTERNAL_USER_ID,
-            EXPIRES_DELTA_SECONDS
-        )
-        payload = jwt_service.validate_chat_jwt(token, COMPANY_SHORT_NAME)
-        assert payload is None
-

tests/services/test_load_documents_service.py

@@ -1,112 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import pytest
-from unittest.mock import patch, MagicMock
-from iatoolkit.services.load_documents_service import LoadDocumentsService
-from iatoolkit.repositories.models import Company
-from iatoolkit.common.exceptions import IAToolkitException
-
-
-class TestLoadDocumentsService:
-    def setup_method(self):
-        self.mock_vector_store = MagicMock()
-        self.mock_file_connector_factory = MagicMock()
-        self.mock_dispatcher = MagicMock()
-        self.mock_doc_service = MagicMock()
-        self.mock_doc_repo = MagicMock()
-        self.mock_profile_repo = MagicMock()
-        self.mock_llm_query_repo = MagicMock()
-
-        self.service = LoadDocumentsService(
-            doc_service=self.mock_doc_service,
-            doc_repo=self.mock_doc_repo,
-            profile_repo=self.mock_profile_repo,
-            llm_query_repo=self.mock_llm_query_repo,
-            vector_store=self.mock_vector_store,
-            file_connector_factory=self.mock_file_connector_factory,
-            dispatcher=self.mock_dispatcher
-        )
-
-        self.company = Company(
-            id=1,
-            name='a big company',
-            short_name='company'
-        )
-        self.mock_profile_repo.get_companies.return_value = [self.company]
-
-    def test_load_company_files_when_missing_connector(self):
-
-        with pytest.raises(IAToolkitException) as excinfo:
-            self.service.load_company_files(company=self.company,
-                                                 connector_config={})
-
-        assert excinfo.value.error_type == IAToolkitException.ErrorType.MISSING_PARAMETER
-        assert "configurar conector" in str(excinfo.value)
-
-    @patch("logging.exception")
-    def test_load_company_files_when_exception(self, mock_logging_exception):
-        mock_connector_config = {"type": "s3"}
-        self.mock_file_connector_factory.create.side_effect = Exception("Test exception")
-
-        result = self.service.load_company_files(company=self.company,
-                                               connector_config=mock_connector_config)
-
-        assert result == {"error": "Test exception"}
-        mock_logging_exception.assert_called_once_with("Loading files error: %s", "Test exception")
-
-
-    def test_load_file_when_document_exists(self, ):
-        filename = "mock_file.pdf"
-        content = b"mock content"
-        self.mock_doc_repo.get.return_value = True
-
-        self.service.load_file_callback(company=self.company,
-                                        filename=filename,
-                                        content=content)
-
-        self.service.doc_service.file_to_txt.assert_not_called()
-        self.mock_doc_repo.insert.assert_not_called()
-        self.service.vector_store.add_document.assert_not_called()
-
-    def test_load_files_when_exception_adding_document(self):
-        self.mock_doc_repo.get.return_value = None
-        self.mock_vector_store.add_document.side_effect = Exception("Error adding document")
-
-        filename = "mock_file.pdf"
-        content = b"mock content"
-        with pytest.raises(IAToolkitException) as excinfo:
-            result = self.service.load_file_callback(
-                    company=self.company,
-                    filename=filename,
-                    content=content)
-
-        assert excinfo.value.error_type == IAToolkitException.ErrorType.LOAD_DOCUMENT_ERROR
-        assert "Error al procesar el archivo" in str(excinfo.value)
-
-    def test_load_when_file_is_created(self):
-        # Mock del archivo y contenido
-        filename = "mock_file.pdf"
-        content = b"mock content"
-        self.service.company = self.company
-        context = {'metadata': {"document_type": "certificate"}}
-
-        # Mock simulando que el archivo no existe
-        self.mock_doc_repo.get.return_value = None
-
-        # Mock de extracción de texto
-        extracted_text = "mock extracted content"
-        self.service.doc_service.file_to_txt.return_value = extracted_text
-        self.mock_dispatcher.get_metadata_from_filename.return_value = {}
-
-        self.service.load_file_callback(company=self.company,
-                                        filename=filename,
-                                        content=content,
-                                        context=context)
-
-        # Verificaciones
-        self.mock_doc_repo.get.assert_called_once_with(company_id=self.company.id, filename=filename)
-        self.service.doc_service.file_to_txt.assert_called_once_with(filename, content)
-        self.service.vector_store.add_document.assert_called_once()

tests/services/test_mail_service.py

@@ -1,70 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-from unittest.mock import MagicMock
-from iatoolkit.services.mail_service import MailService
-
-
-class TestMailService:
-
-    def setup_method(self):
-        self.mock_mail_app = MagicMock()
-
-        # Instancia de MailService con la dependencia inyectada como mock
-        self.mail_service = MailService(mail_app=self.mock_mail_app)
-
-        # Datos por defecto para enviar email
-        self.recipient = 'destinatario@test.com'
-        self.subject = 'Prueba'
-        self.body = 'Contenido del mensaje'
-
-
-    def test_send_mail_when_success(self):
-        result = self.mail_service.send_mail(
-            recipient=self.recipient,
-            subject=self.subject,
-            body=self.body,
-            attachments=[]
-        )
-
-        # Comprobamos si mail_app.send_email fue invocado correctamente
-        self.mock_mail_app.send_email.assert_called_once_with(
-            sender={'email': 'iatoolkit@iatoolkit.com', 'name': 'IAToolkit'},
-            to=self.recipient,
-            subject=self.subject,
-            body=self.body,
-            attachments=[]        )
-        assert result == 'mail enviado'
-
-    def test_send_mail_when_no_recipient(self):
-        # Probamos el comportamiento cuando falta el receptor del mensaje
-        result = self.mail_service.send_mail(
-            subject=self.subject,
-            body=self.body
-        )
-
-        '''
-        self.mock_mail_app.send_email.assert_called_once_with(
-            sender={'email': 'iatoolkit@iatoolkit.com', 'name': 'IAToolkit'},
-            to=None,
-            subject=self.subject,
-            body=self.body,
-            attach=None,
-            attachments=None
-        )
-        assert result == 'mail enviado'
-        '''
-
-    def test_send_mail_partial_args(self):
-        # Comprobamos cuando faltan parcialmente argumentos como subject y body
-        result = self.mail_service.send_mail(recipient=self.recipient)
-
-        self.mock_mail_app.send_email.assert_called_once_with(
-            sender={'email': 'iatoolkit@iatoolkit.com', 'name': 'IAToolkit'},
-            to=self.recipient,
-            subject=None,
-            body=None,
-            attachments=[] )
-        assert result == 'mail enviado'