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

tests/services/test_profile_service.py

@@ -1,379 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-from unittest.mock import MagicMock, patch
-from iatoolkit.repositories.profile_repo import ProfileRepo
-from iatoolkit.services.profile_service import ProfileService
-from iatoolkit.services.query_service import QueryService
-from iatoolkit.services.user_session_context_service import UserSessionContextService
-from flask_bcrypt import generate_password_hash
-from iatoolkit.repositories.models import User, Company
-from iatoolkit.infra.mail_app import MailApp
-import os
-
-class TestProfileService:
-    @classmethod
-    def setup_class(cls):
-        cls.patcher = patch.dict(os.environ, {"USER_VERIF_KEY": "mocked_secret_key"})
-        cls.patcher.start()
-
-    def setup_method(self):
-        self.repo = MagicMock(ProfileRepo)
-        self.mail_app = MagicMock(MailApp)
-        self.session_context = MagicMock(UserSessionContextService)
-        self.query_service = MagicMock(QueryService)
-
-        # init the service with the mock
-        self.service = ProfileService(
-            profile_repo=self.repo,
-            session_context_service=self.session_context,
-            query_service=self.query_service,
-            mail_app=self.mail_app)
-
-        self.mock_user = User(email='test@opensoft.cl',
-                            first_name='fernando', last_name='libe',
-                            password=generate_password_hash("password").decode("utf-8"), verified=True)
-
-        self.mock_company = Company(name='my company',
-                                    short_name='test_company',
-                                    logo_file='company_logo.jpg')
-        self.repo.get_company_by_short_name.return_value = self.mock_company
-
-        self.mock_user.companies = [self.mock_company, Company(id=2, name="Test Company 2")]
-
-    def teardown_method(self):
-        self.patcher.stop()
-
-    def test_login_when_exception(self):
-        self.repo.get_user_by_email.side_effect = Exception('an error')
-        response = self.service.login(self.mock_company.short_name,
-                                      'fernando',
-                                      'a password'
-                                      )
-
-        assert "an error" == response['error']
-
-    def test_login_when_user_not_exist(self):
-        self.repo.get_user_by_email.return_value = None
-        response = self.service.login(self.mock_company.short_name,
-                                      'fernando',
-                                      'a password')
-
-        assert "Usuario no encontrado" == response['error']
-
-    def test_login_when_invalid_password(self):
-        # Simula un usuario válido pero con una contraseña incorrecta
-        mock_user = MagicMock()
-        mock_user.password = generate_password_hash("correct_password").decode("utf-8")
-        mock_user.verified = True
-        self.repo.get_user_by_email.return_value = mock_user
-
-        response = self.service.login(self.mock_company.short_name,
-                                      'fernando',
-                                      'wrong_password'
-                                      )
-
-        assert "Contraseña inválida" == response['error']
-
-    def test_login_when_company_not_in_user_companies(self):
-        self.repo.get_user_by_email.return_value = self.mock_user
-        self.mock_user.password = generate_password_hash("password").decode("utf-8")
-        self.mock_user.companies = [Company(id=2, name="Test Company 2")]
-
-        response = self.service.login(self.mock_company.short_name,
-                                      'fernando',
-                                      'password'
-                                      )
-
-        assert "Usuario no esta autorizado para esta empresa" == response['error']
-
-    def test_login_when_unverified_account(self):
-        self.mock_user.password = generate_password_hash("password").decode("utf-8")
-        self.mock_user.verified = False
-        self.repo.get_user_by_email.return_value = self.mock_user
-
-        response = self.service.login(self.mock_company.short_name,
-                                      'fernando',
-                                      'password'
-                                      )
-
-        assert "Tu cuenta no ha sido verificada" in response['error']
-
-    @patch("iatoolkit.services.profile_service.SessionManager")
-    def test_login_when_ok(self, mock_session):
-        mock_session.set.return_value = True
-        self.mock_user.password = generate_password_hash("password").decode("utf-8")
-        self.repo.get_user_by_email.return_value = self.mock_user
-
-        response = self.service.login(self.mock_company.short_name,
-                                      'test@email.com',
-                                      'password'
-                                      )
-
-        assert "Login exitoso" == response['message']
-
-    def test_signup_when_invalid_company(self):
-        self.repo.get_company_by_short_name.return_value = None
-
-        response = self.service.signup(
-            self.mock_company.short_name,
-            email='test@email.com',
-            first_name='Test', last_name='User',
-            password="password", confirm_password="password",
-            verification_url='http://verification'
-        )
-
-        assert "empresa test_company no existe" in response['error']
-
-    def test_signup_when_user_exist_and_invalid_password(self):
-        self.mock_user.password = generate_password_hash("password").decode("utf-8")
-        self.repo.get_user_by_email.return_value = self.mock_user
-
-        response = self.service.signup(
-            self.mock_company.short_name,
-            email='test@email.com',
-            first_name='Test', last_name='User',
-            password="invalid_password", confirm_password="password",
-            verification_url='http://verification'
-        )
-
-        assert "contraseña es incorrecta" in response['error']
-
-
-    def test_signup_when_user_exist_and_already_register(self):
-        self.repo.get_user_by_email.return_value = self.mock_user
-
-        response = self.service.signup(
-            self.mock_company.short_name,
-            email='test@email.com',
-            first_name='Test', last_name='User',
-            password="password", confirm_password="password",
-            verification_url='http://verification'
-        )
-
-        assert "Usuario ya registrado" in response['error']
-
-    def test_signup_when_user_exist_and_not_in_company(self):
-        self.repo.get_user_by_email.return_value = self.mock_user
-        self.mock_user.companies = []
-
-        response = self.service.signup(
-            self.mock_company.short_name,
-            email='test@email.com',
-            first_name='Test', last_name='User',
-            password="password", confirm_password="password",
-            verification_url='http://verification'
-        )
-
-        assert "Usuario asociado" in response['message']
-        self.repo.save_user.assert_called_once()
-
-    def test_signup_when_passwords_different(self):
-        self.repo.get_user_by_email.return_value = None
-
-        response = self.service.signup(
-            self.mock_company.short_name,
-            email='test@email.com',
-            first_name='Test', last_name='User',
-            password="Password1", confirm_password="Password2$1",
-            verification_url='http://verification'
-        )
-
-        assert "contraseñas no coinciden" in response['error']
-
-    def test_signup_when_passwords_incorrect2(self):
-        self.repo.get_user_by_email.return_value = None
-
-        response = self.service.signup(
-            self.mock_company.short_name,
-            email='test@email.com',
-            first_name='Test', last_name='User',
-            password="Password", confirm_password="Password",
-            verification_url='http://verification'
-        )
-
-        assert "número" in response['error']
-
-    def test_signup_when_passwords_incorrect3(self):
-        self.repo.get_user_by_email.return_value = None
-
-        response = self.service.signup(
-            self.mock_company.short_name,
-            email='test@email.com',
-            first_name='Test', last_name='User',
-            password="Passw1", confirm_password="Passw1",
-            verification_url='http://verification'
-        )
-
-        assert "8 caracteres" in response['error']
-
-    def test_signup_when_passwords_incorrect4(self):
-        self.repo.get_user_by_email.return_value = None
-
-        response = self.service.signup(
-            self.mock_company.short_name,
-            email='test@email.com',
-            first_name='Test', last_name='User',
-            password="password123", confirm_password="password123",
-            verification_url='http://verification'
-        )
-
-        assert "mayúscula" in response['error']
-
-    def test_signup_when_passwords_incorrect5(self):
-        self.repo.get_user_by_email.return_value = None
-
-        response = self.service.signup(
-            self.mock_company.short_name,
-            email='test@email.com',
-            first_name='Test', last_name='User',
-            password="Password123", confirm_password="Password123",
-            verification_url='http://verification'
-        )
-
-        assert "especial" in response['error']
-
-    def test_signup_when_ok(self):
-        self.repo.get_user_by_email.return_value = None
-        self.mail_app.send_email.return_value = True
-
-        response = self.service.signup(
-            self.mock_company.short_name,
-            email='test@email.com',
-            first_name='Test', last_name='User',
-            password="Password$1", confirm_password="Password$1",
-            verification_url='http://verification'
-        )
-
-        assert "Registro exitoso" in response['message']
-        self.mail_app.send_email.assert_called()
-
-    def test_signup_when_exception(self):
-        self.repo.get_user_by_email.side_effect = Exception('an error')
-        response = self.service.signup(
-            self.mock_company.short_name,
-            email='test@email.com',
-            first_name='Test', last_name='User',
-            password="password", confirm_password="password",
-            verification_url='http://verification'
-        )
-
-        assert "an error" == response['error']
-
-    def test_get_companies_when_ok(self):
-        self.repo.get_companies.return_value = [self.mock_company]
-        companies = self.service.get_companies()
-        assert companies == [self.mock_company]
-
-    def test_get_company_by_short_name_when_ok(self):
-        company = self.service.get_company_by_short_name('test_company')
-        assert company == self.mock_company
-
-    def test_update_user(self):
-        self.repo.update_user.return_value = self.mock_user
-        user = self.service.update_user('fl@opensoft.cl', first_name='fernando')
-
-        assert user == self.mock_user
-
-    def test_verify_account_when_user_not_exist(self):
-        self.repo.get_user_by_email.return_value = None
-
-        response = self.service.verify_account(email='test@email.com')
-
-        assert "El usuario no existe." in response['error']
-
-    def test_verify_account_when_exception(self):
-        self.repo.get_user_by_email.side_effect = Exception('an error')
-        response = self.service.verify_account(email='test@email.com')
-
-        assert "an error" == response['error']
-
-    def test_verify_account_when_ok(self):
-        self.repo.get_user_by_email.return_value = self.mock_user
-        response = self.service.verify_account(email='test@email.com')
-
-        assert "cuenta ha sido verificada" in response['message']
-
-    def test_change_password_when_password_mismatch(self):
-        response = self.service.change_password(
-            email='test@email.com',
-            temp_code='ABC',
-            new_password='pass1',
-            confirm_password='pass2'
-        )
-        assert "contraseñas no coinciden" in response['error']
-
-    def test_change_passworwd_when_invalid_code(self):
-        self.repo.get_user_by_email.return_value = self.mock_user
-        self.mock_user.temp_code = 'xYhvt'
-        response = self.service.change_password(
-            email='test@email.com',
-            temp_code='ABC',
-            new_password='pass1',
-            confirm_password='pass1'
-        )
-        assert "código temporal no es válido" in response['error']
-
-    def test_change_password_when_ok(self):
-        self.repo.get_user_by_email.return_value = self.mock_user
-        self.mock_user.temp_code = 'ABC'
-        response = self.service.change_password(
-            email='test@email.com',
-            temp_code=self.mock_user.temp_code,
-            new_password='pass1',
-            confirm_password='pass1'
-        )
-        assert "clave se cambio correctamente" in response['message']
-
-    def test_change_password_when_exception(self):
-        self.repo.get_user_by_email.return_value = self.mock_user
-        self.repo.update_password.side_effect = Exception('db error')
-        response = self.service.change_password(
-            email='test@email.com',
-            temp_code=self.mock_user.temp_code,
-            new_password='pass1',
-            confirm_password='pass1'
-        )
-        assert "db error" == response['error']
-
-    def test_forgot_password_when_user_not_exist(self):
-        self.repo.get_user_by_email.return_value = None
-        response = self.service.forgot_password(
-            email='test@email.com',
-            reset_url='http://a_reset_utl'
-        )
-        assert "El usuario no existe" in response['error']
-
-    def test_forgot_password_when_ok(self):
-        self.repo.get_user_by_email.return_value = self.mock_user
-        response = self.service.forgot_password(
-            email='test@email.com',
-            reset_url='http://a_reset_utl'
-        )
-        assert "se envio mail para cambio de clave" in response['message']
-        self.mail_app.send_email.assert_called()
-
-    def test_forgot_password_when_exception(self):
-        self.repo.get_user_by_email.return_value = self.mock_user
-        self.mail_app.send_email.side_effect = Exception('mail error')
-        response = self.service.forgot_password(
-            email='test@email.com',
-            reset_url='http://a_reset_utl'
-        )
-
-        assert "mail error" == response['error']
-
-    def test_new_api_key_when_not_company(self):
-        self.repo.get_company_by_short_name.return_value = None
-        response = self.service.new_api_key(company_short_name='test_company')
-        assert "test_company no existe" in response['error']
-
-    def test_new_api_key_when_ok(self):
-        self.repo.get_company_by_short_name.return_value = self.mock_company
-        response = self.service.new_api_key(company_short_name='test_company')
-
-        self.repo.create_api_key.assert_called()
-        assert response['api-key'] != ''
-

tests/services/test_prompt_manager_service.py

@@ -1,190 +0,0 @@
-import pytest
-from unittest.mock import MagicMock, patch, mock_open
-
-# Asegúrate de que todas las importaciones necesarias estén presentes y correctas
-from iatoolkit.services.prompt_manager_service import PromptService
-from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
-from iatoolkit.repositories.profile_repo import ProfileRepo
-from iatoolkit.repositories.models import Prompt, PromptCategory, Company
-from iatoolkit.common.exceptions import IAToolkitException
-
-
-class TestPromptService:
-    @pytest.fixture(autouse=True)
-    def setup(self):
-        """Configura mocks y la instancia del servicio para cada test."""
-        self.llm_query_repo = MagicMock(spec=LLMQueryRepo)
-        self.profile_repo = MagicMock(spec=ProfileRepo)
-        self.prompt_service = PromptService(
-            llm_query_repo=self.llm_query_repo,
-            profile_repo=self.profile_repo
-        )
-        self.mock_company = MagicMock(spec=Company)
-        self.mock_company.id = 1
-        self.mock_company.name = 'Test Company'
-        self.mock_company.short_name = 'test_co'
-
-    # --- Tests para get_user_prompts ---
-
-    def test_get_user_prompts_company_not_found(self):
-        """Prueba que se devuelve un error cuando la empresa no existe."""
-        self.profile_repo.get_company_by_short_name.return_value = None
-        result = self.prompt_service.get_user_prompts(company_short_name='nonexistent_company')
-        assert result == {'error': 'No existe la empresa: nonexistent_company'}
-
-    def test_get_user_prompts_no_prompts_exist(self):
-        """Prueba que se devuelve una lista vacía cuando la empresa no tiene prompts."""
-        self.profile_repo.get_company_by_short_name.return_value = self.mock_company
-        self.llm_query_repo.get_prompts.return_value = []
-        result = self.prompt_service.get_user_prompts(company_short_name='test_company')
-        assert result == {'message': []}
-
-    def test_get_user_prompts_filters_inactive_and_groups_correctly(self):
-        """Prueba que los prompts inactivos se filtran y que los activos se agrupan correctamente."""
-        # Usamos instancias reales de los modelos en lugar de Mocks para los datos.
-        category = PromptCategory(name='General', order=1)
-        active_prompt = Prompt(name='active_prompt', description='Active', active=True, order=1, category=category)
-        inactive_prompt = Prompt(name='inactive_prompt', description='Inactive', active=False, order=2,
-                                 category=category)
-
-        self.profile_repo.get_company_by_short_name.return_value = self.mock_company
-        self.llm_query_repo.get_prompts.return_value = [active_prompt, inactive_prompt]
-
-        result = self.prompt_service.get_user_prompts(company_short_name='test_company')
-
-        # Verificar que solo hay una categoría en el resultado
-        assert len(result['message']) == 1
-        # Verificar que dentro de esa categoría, solo hay un prompt (el activo)
-        assert len(result['message'][0]['prompts']) == 1
-        # Verificar que el prompt es el correcto
-        assert result['message'][0]['prompts'][0]['prompt'] == 'active_prompt'
-
-    # --- Tests para get_system_prompt ---
-
-    @patch('iatoolkit.services.prompt_manager_service.importlib.resources.read_text')
-    def test_get_system_prompt_success(self, mock_read_text):
-        """Prueba la obtención exitosa de los prompts de sistema concatenados."""
-        prompt1 = Prompt(filename='system1.prompt')
-        prompt2 = Prompt(filename='system2.prompt')
-        self.llm_query_repo.get_system_prompts.return_value = [prompt1, prompt2]
-
-        # Configurar el mock para devolver diferentes contenidos en cada llamada
-        mock_read_text.side_effect = [
-            'Contenido 1',
-            'Contenido 2'
-        ]
-
-        result = self.prompt_service.get_system_prompt()
-
-        assert result == "Contenido 1\nContenido 2"
-        assert mock_read_text.call_count == 2
-
-    @patch('iatoolkit.services.prompt_manager_service.os.path.exists', return_value=False)
-    @patch('iatoolkit.services.prompt_manager_service.logging')
-    def test_get_system_prompt_file_not_found(self, mock_logging, mock_exists):
-        """Prueba que se loguea una advertencia si un archivo de prompt no existe."""
-        prompt1 = Prompt(filename='missing.prompt')
-        self.llm_query_repo.get_system_prompts.return_value = [prompt1]
-
-        result = self.prompt_service.get_system_prompt()
-
-        assert result == ""
-        mock_logging.warning.assert_called_once()
-        assert "no existe" in mock_logging.warning.call_args[0][0]
-
-    def test_get_system_prompt_handles_repo_exception(self):
-        """Prueba que se maneja una excepción del repositorio."""
-        self.llm_query_repo.get_system_prompts.side_effect = Exception("DB Connection Error")
-
-        with pytest.raises(IAToolkitException) as exc_info:
-            self.prompt_service.get_system_prompt()
-
-        assert exc_info.value.error_type == IAToolkitException.ErrorType.PROMPT_ERROR
-        assert "DB Connection Error" in str(exc_info.value)
-
-    # --- Tests para get_prompt_content ---
-
-    @patch('iatoolkit.services.prompt_manager_service.os.path.exists', return_value=True)
-    @patch('builtins.open', new_callable=mock_open, read_data='Contenido específico del prompt.')
-    def test_get_prompt_content_success(self, mock_file, mock_exists):
-        """Prueba la obtención exitosa del contenido de un prompt específico."""
-        mock_prompt = Prompt(filename='my_prompt.prompt')
-        self.llm_query_repo.get_prompt_by_name.return_value = mock_prompt
-
-        result = self.prompt_service.get_prompt_content(self.mock_company, 'my_prompt')
-
-        assert result == 'Contenido específico del prompt.'
-        self.llm_query_repo.get_prompt_by_name.assert_called_once_with(self.mock_company, 'my_prompt')
-
-    def test_get_prompt_content_prompt_not_in_db(self):
-        """Prueba que se lanza una excepción si el prompt no se encuentra en la BD."""
-        self.llm_query_repo.get_prompt_by_name.return_value = None
-
-        with pytest.raises(IAToolkitException) as exc_info:
-            self.prompt_service.get_prompt_content(self.mock_company, 'non_existent_prompt')
-
-        assert exc_info.value.error_type == IAToolkitException.ErrorType.DOCUMENT_NOT_FOUND
-
-    # --- Tests para create_prompt ---
-
-    @patch('iatoolkit.services.prompt_manager_service.os.path.exists', return_value=True)
-    def test_create_prompt_success_for_company(self, mock_exists):
-        """Prueba la creación exitosa de un prompt para una compañía."""
-        self.prompt_service.create_prompt(
-            prompt_name='new_prompt',
-            description='A new prompt',
-            order=1,
-            company=self.mock_company,
-            custom_fields = [{'data_key': 'key', 'label': ' a label'}]
-        )
-
-        self.llm_query_repo.create_or_update_prompt.assert_called_once()
-        call_args = self.llm_query_repo.create_or_update_prompt.call_args[0]
-        prompt_object = call_args[0]
-
-        assert isinstance(prompt_object, Prompt)
-        assert prompt_object.name == 'new_prompt'
-        assert prompt_object.company_id == self.mock_company.id
-        assert not prompt_object.is_system_prompt
-        assert 'new_prompt.prompt' in prompt_object.filename
-        assert prompt_object.custom_fields == [{'data_key': 'key', 'label': ' a label', 'type': 'text'}]
-
-    @patch('iatoolkit.services.prompt_manager_service.os.path.exists', return_value=True)
-    def test_create_prompt_when_invalid_custom_fields(self, mock_exists):
-        with pytest.raises(IAToolkitException) as exc_info:
-            self.prompt_service.create_prompt(
-                prompt_name='new_prompt',
-                description='A new prompt',
-                order=1,
-                company=self.mock_company,
-                custom_fields=[{'label': ' a label'}]
-            )
-
-        assert exc_info.value.error_type == IAToolkitException.ErrorType.INVALID_PARAMETER
-
-    @patch('iatoolkit.services.prompt_manager_service.os.path.exists', return_value=False)
-    def test_create_prompt_fails_if_file_does_not_exist(self, mock_exists):
-        """Prueba que la creación falla si el archivo de plantilla no existe."""
-        with pytest.raises(IAToolkitException) as exc_info:
-            self.prompt_service.create_prompt(
-                prompt_name='prompt_with_missing_file',
-                description='Desc',
-                order=1,
-                company=self.mock_company
-            )
-        assert exc_info.value.error_type == IAToolkitException.ErrorType.INVALID_NAME
-        assert "No existe el archivo de prompt" in str(exc_info.value)
-
-    @patch('iatoolkit.services.prompt_manager_service.os.path.exists', return_value=True)
-    def test_create_prompt_handles_db_exception(self, mock_exists):
-        """Prueba que se maneja una excepción de la base de datos al guardar."""
-        self.llm_query_repo.create_or_update_prompt.side_effect = Exception("DB Unique Constraint Failed")
-
-        with pytest.raises(IAToolkitException) as exc_info:
-            self.prompt_service.create_prompt(
-                prompt_name='any_prompt',
-                description='Desc',
-                order=1,
-                company=self.mock_company
-            )
-        assert exc_info.value.error_type == IAToolkitException.ErrorType.DATABASE_ERROR