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

tests/services/test_tasks_service.py

@@ -1,252 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import pytest
-from unittest.mock import MagicMock, patch
-from iatoolkit.services.tasks_service import TaskService
-from iatoolkit.infra.call_service import CallServiceClient
-from iatoolkit.repositories.models import Task, TaskStatus, TaskType, Company
-from iatoolkit.common.exceptions import IAToolkitException
-from datetime import datetime, timedelta
-
-
-class TestTaskService:
-
-    def setup_method(self):
-        self.mock_task_repo = MagicMock()
-        self.mock_query_service = MagicMock()
-        self.mock_profile_repo = MagicMock()
-        self.mock_call_service = MagicMock(spec=CallServiceClient)
-
-        self.task_service = TaskService(
-            task_repo=self.mock_task_repo,
-            query_service=self.mock_query_service,
-            profile_repo=self.mock_profile_repo,
-            call_service=self.mock_call_service
-        )
-
-        self.mock_company = Company(id=1, name='test_company', short_name='test_company')
-        self.mock_task_type = TaskType(id=10, prompt_template='prompt.tpl')
-
-        self.task_mock = Task(
-            company_id=self.mock_company.id,
-            task_type_id=self.mock_task_type.id,
-            company_task_id=0,
-            client_data={"key": "value"},
-            execute_at=datetime.now(),
-            status=TaskStatus.pendiente,
-            files=[]
-            )
-        self.task_mock.company = self.mock_company
-        self.task_mock.task_type = self.mock_task_type
-
-    def test_create_task_when_company_not_found(self):
-        self.mock_profile_repo.get_company_by_short_name.return_value = None
-
-        with pytest.raises(IAToolkitException) as excinfo:
-            self.task_service.create_task(
-                company_short_name="non_existent_company",
-                task_type_name="test_task_type",
-                client_data={}
-            )
-
-        assert excinfo.value.error_type == IAToolkitException.ErrorType.INVALID_NAME
-        assert "No existe la empresa" in str(excinfo.value)
-
-    def test_create_task_when_tasktype_not_found(self):
-        self.mock_profile_repo.get_company_by_short_name.return_value = self.mock_company
-        self.mock_task_repo.get_task_type.return_value = None
-
-        with pytest.raises(IAToolkitException) as excinfo:
-            self.task_service.create_task(
-                company_short_name="test_company",
-                task_type_name="non_existent_type",
-                client_data={}
-            )
-
-        assert excinfo.value.error_type == IAToolkitException.ErrorType.INVALID_NAME
-        assert "No existe el task_type" in str(excinfo.value)
-
-    def test_create_task_when_future_execution(self):
-        future_date = datetime.now() + timedelta(days=1)
-
-        self.mock_profile_repo.get_company_by_short_name.return_value = self.mock_company
-        self.mock_task_repo.get_task_type.return_value = self.mock_task_type
-        self.mock_task_repo.create_task.return_value = self.task_mock
-        self.task_mock.execute_at = future_date
-
-        result_task = self.task_service.create_task(
-            company_short_name="test_company",
-            task_type_name="test_task_type",
-            client_data={"key": "value"},
-            execute_at=future_date
-        )
-
-        assert result_task.execute_at == future_date
-        self.mock_query_service.llm_query.assert_not_called()
-        self.mock_task_repo.update_task.assert_not_called()
-
-    def test_create_task_when_ok(self):
-        self.mock_profile_repo.get_company_by_short_name.return_value = self.mock_company
-        self.mock_task_repo.get_task_type.return_value = self.mock_task_type
-        self.mock_task_repo.create_task.return_value = self.task_mock
-
-        result_task = self.task_service.create_task(
-            company_short_name="test_company",
-            task_type_name="test_task_type",
-            client_data={"key": "value"},
-        )
-
-        assert result_task.status == TaskStatus.pendiente
-        self.mock_query_service.llm_query.assert_not_called()
-
-    def test_review_task_when_task_not_found(self):
-        self.mock_task_repo.get_task_by_id.return_value = None
-
-        with pytest.raises(IAToolkitException) as excinfo:
-            self.task_service.review_task(task_id=99,
-                                          review_user='pgonzalez',
-                                          approved=True,
-                                          comment='Validación aprobada')
-
-        assert excinfo.value.error_type.name == "TASK_NOT_FOUND"
-
-    def test_review_task_when_invalid_status(self):
-        self.mock_task_repo.get_task_by_id.return_value = self.task_mock
-
-        with pytest.raises(IAToolkitException) as excinfo:
-            self.task_service.review_task(task_id=99,
-                                          review_user='pgonzalez',
-                                          approved=True,
-                                          comment='Validación aprobada')
-
-        assert excinfo.value.error_type.name == "INVALID_STATE"
-
-    def test_review_task_when_ok(self):
-        self.task_mock.status = TaskStatus.ejecutado
-        self.mock_task_repo.get_task_by_id.return_value = self.task_mock
-
-        result = self.task_service.review_task(task_id=99,
-                                          review_user='pgonzalez',
-                                          approved=True,
-                                          comment='Validación aprobada')
-
-        assert self.task_mock.status == TaskStatus.aprobada
-        assert self.task_mock.approved == True
-        self.mock_task_repo.update_task.assert_called_once_with(self.task_mock)
-
-
-    def test_execute_task_when_llm_error(self):
-        llm_response = {
-            "query_id": 456,
-            "valid_response": False,
-            "error": "IA error"}
-        self.mock_query_service.llm_query.return_value = llm_response
-
-        with pytest.raises(IAToolkitException) as excinfo:
-            self.task_service.execute_task(self.task_mock)
-
-        assert excinfo.value.error_type == IAToolkitException.ErrorType.LLM_ERROR
-        assert "IA error" in str(excinfo.value)
-
-
-    def test_execute_task_when_llm_response_valid(self):
-        llm_response = {"query_id": 123, "valid_response": True}
-        self.mock_query_service.llm_query.return_value = llm_response
-        result_task = self.task_service.execute_task(self.task_mock)
-
-        assert result_task.llm_query_id == 123
-        assert result_task.status == TaskStatus.ejecutado
-        self.mock_task_repo.update_task.assert_called_once_with(result_task)
-
-    def test_execute_task_when_exception_in_callback(self):
-        llm_response = {
-            "query_id": 123,
-            "valid_response": True,
-            "answer": 'an llm answer',
-            "additional_data": {}
-        }
-        self.mock_query_service.llm_query.return_value = llm_response
-        self.task_mock.callback_url = "http://test.com"
-        self.mock_call_service.post.side_effect =Exception("timeout")
-        with pytest.raises(IAToolkitException) as excinfo:
-            result_task = self.task_service.execute_task(self.task_mock)
-
-        assert excinfo.value.error_type == IAToolkitException.ErrorType.REQUEST_ERROR
-        assert "timeout" in str(excinfo.value)
-
-    def test_execute_task_when_llm_invalid_response(self):
-        llm_response = {
-            "query_id": 123,
-            "valid_response": False,
-            "answer": 'an llm answer',
-            "additional_data": {}
-        }
-        self.mock_query_service.llm_query.return_value = llm_response
-        self.task_mock.callback_url = "http://test.com"
-        self.task_mock.client_data = {"key": "value"}
-        self.mock_call_service.post.return_value = {'status': 'ok'}, 200
-        result_task = self.task_service.execute_task(self.task_mock)
-
-        assert result_task.status == TaskStatus.fallida
-        self.mock_call_service.post.assert_called_once()
-
-    def test_execute_task_when_callback_ok(self):
-        llm_response = {
-            "query_id": 123,
-            "valid_response": True,
-            "answer": 'an llm answer',
-            "additional_data": {}
-        }
-        self.mock_query_service.llm_query.return_value = llm_response
-        self.task_mock.callback_url = "http://test.com"
-        self.task_mock.client_data = {"key": "value"}
-        self.mock_call_service.post.return_value = {'status': 'ok'}, 200
-        result_task = self.task_service.execute_task(self.task_mock)
-
-        assert result_task.llm_query_id == 123
-        assert result_task.status == TaskStatus.ejecutado
-        self.mock_call_service.post.assert_called_once()
-
-    def test_trigger_pending_tasks_when_exception(self):
-        self.mock_task_repo.get_pending_tasks.side_effect = Exception("Error al obtener tareas pendientes")
-        with pytest.raises(IAToolkitException) as excinfo:
-            self.task_service.trigger_pending_tasks('open')
-
-        assert excinfo.value.error_type == IAToolkitException.ErrorType.TASK_EXECUTION_ERROR
-
-    def test_trigger_pending_tasks_when_ok(self):
-        self.mock_task_repo.get_pending_tasks.return_value = [self.task_mock]
-        response = self.task_service.trigger_pending_tasks('open')
-
-        assert response['message'] == '1 tareas ejecutadas.'
-
-    @patch("iatoolkit.services.tasks_service.secure_filename", return_value="secure_file.txt")
-    def test_get_task_files_when_save_exception(self, mock_secure_filename):
-        uploaded_file_mock = MagicMock()
-        uploaded_file_mock.read.side_effect = Exception("Error Guardando")
-
-        with pytest.raises(IAToolkitException) as excinfo:
-            self.task_service.get_task_files([uploaded_file_mock])
-
-        assert excinfo.value.error_type == IAToolkitException.ErrorType.FILE_IO_ERROR
-        assert "Error al extraer el contenido del archivo secure_file.txt: Error Guardando" in str(excinfo.value)
-
-
-    @patch("iatoolkit.services.tasks_service.secure_filename", return_value="secure_file.txt")
-    def test_get_task_files_when_success(self, mock_secure_filename):
-        uploaded_file_mock = MagicMock()
-        uploaded_file_mock.filename = "file.txt"
-        uploaded_file_mock.content_type = "text/plain"
-
-        # mockear el método save del archivo
-        uploaded_file_mock.save = MagicMock()
-
-        files_info = self.task_service.get_task_files([uploaded_file_mock])
-
-        assert len(files_info) == 1
-        assert files_info[0]['filename'] == "secure_file.txt"
-        assert files_info[0]['type'] == "text/plain"
-

tests/services/test_user_feedback_service.py

@@ -1,389 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-from unittest.mock import MagicMock
-from iatoolkit.repositories.profile_repo import ProfileRepo
-from iatoolkit.services.user_feedback_service import UserFeedbackService
-from iatoolkit.repositories.models import Company, UserFeedback
-from iatoolkit.infra.google_chat_app import GoogleChatApp
-
-
-class TestUserFeedbackService:
-    def setup_method(self):
-        self.profile_repo = MagicMock(ProfileRepo)
-        self.google_chat_app = MagicMock(GoogleChatApp)
-
-        # init the service with the mocks
-        self.service = UserFeedbackService(
-            profile_repo=self.profile_repo,
-            google_chat_app=self.google_chat_app
-        )
-
-        self.company = Company(name='my company',
-                                    short_name='test_company',
-                                    logo_file='company_logo.jpg')
-        self.profile_repo.get_company_by_short_name.return_value = self.company
-
-        self.user_feedback = UserFeedback(
-                    company_id=self.company.id,
-                    message='feedback message for testing',
-                    external_user_id='flibedinsky',
-                    rating=4)
-
-        # Mock successful Google Chat response
-        self.google_chat_app.send_message.return_value = {
-            'success': True,
-            'message': 'Mensaje enviado correctamente'
-        }
-
-    def test_feedback_when_exception(self):
-        self.profile_repo.get_company_by_short_name.side_effect = Exception('an error')
-        response = self.service.new_feedback(
-                        company_short_name='my_company',
-                        message='feedback message for testing',
-                        external_user_id='flibedinsky',
-                        space='spaces/test-space',
-                        type='MESSAGE_TRIGGER',
-                        rating=3
-                        )
-
-        assert 'an error' == response['error']
-
-    def test_feedback_when_company_not_exist(self):
-        self.profile_repo.get_company_by_short_name.return_value = None
-        response = self.service.new_feedback(
-                        company_short_name='my_company',
-                        message='feedback message for testing',
-                        external_user_id='flibedinsky',
-                        space='spaces/test-space',
-                        type='MESSAGE_TRIGGER',
-                        rating=5
-                        )
-
-        assert 'No existe la empresa: my_company' == response['error']
-
-    def test_feedback_when_error_saving_in_database(self):
-        self.profile_repo.save_feedback.return_value = None
-        response = self.service.new_feedback(
-                        company_short_name='my_company',
-                        message='feedback message for testing',
-                        external_user_id='flibedinsky',
-                        space='spaces/test-space',
-                        type='MESSAGE_TRIGGER',
-                        rating=2
-                        )
-
-        assert 'No se pudo guardar el feedback' == response['error']
-
-    def test_feedback_when_ok(self):
-        self.profile_repo.save_feedback.return_value = UserFeedback
-        response = self.service.new_feedback(
-                        company_short_name='my_company',
-                        message='feedback message for testing',
-                        external_user_id='flibedinsky',
-                        space='spaces/test-space',
-                        type='MESSAGE_TRIGGER',
-                        rating=4
-                        )
-
-        assert 'Feedback guardado correctamente' == response['message']
-
-    # Nuevos tests para Google Chat
-    def test_feedback_sends_google_chat_notification_success(self):
-        """Test that Google Chat notification is sent successfully"""
-        self.profile_repo.save_feedback.return_value = UserFeedback
-
-        response = self.service.new_feedback(
-            company_short_name='my_company',
-            message='feedback message for testing',
-            external_user_id='flibedinsky',
-            space='spaces/AAQAupQldd4',
-            type='MESSAGE_TRIGGER',
-            rating=5
-        )
-
-        # Verify Google Chat was called
-        self.google_chat_app.send_message.assert_called_once()
-
-        # Verify the call arguments
-        call_args = self.google_chat_app.send_message.call_args[1]['message_data']
-        assert call_args['type'] == 'MESSAGE_TRIGGER'
-        assert call_args['space']['name'] == 'spaces/AAQAupQldd4'
-        assert '*Nuevo feedback de my_company*' in call_args['message']['text']
-        assert '*Usuario:* flibedinsky' in call_args['message']['text']
-        assert '*Mensaje:* feedback message for testing' in call_args['message']['text']
-        assert '*Calificación:* 5' in call_args['message']['text']
-
-        # Verify feedback was still saved successfully
-        assert 'Feedback guardado correctamente' == response['message']
-
-    def test_feedback_google_chat_notification_failure_does_not_affect_save(self):
-        """Test that Google Chat failure doesn't prevent feedback from being saved"""
-        self.profile_repo.save_feedback.return_value = UserFeedback
-
-        # Mock Google Chat failure
-        self.google_chat_app.send_message.return_value = {
-            'success': False,
-            'message': 'Error al enviar mensaje'
-        }
-
-        response = self.service.new_feedback(
-            company_short_name='my_company',
-            message='feedback message for testing',
-            external_user_id='flibedinsky',
-            space='spaces/AAQAupQldd4',
-            type='MESSAGE_TRIGGER',
-            rating=1
-        )
-
-        # Verify Google Chat was called
-        self.google_chat_app.send_message.assert_called_once()
-
-        # Verify feedback was still saved successfully despite Google Chat failure
-        assert 'Feedback guardado correctamente' == response['message']
-
-    def test_feedback_google_chat_exception_returns_error(self):
-        """Test that Google Chat exception returns an error response"""
-        self.profile_repo.save_feedback.return_value = UserFeedback
-
-        # Mock Google Chat exception
-        self.google_chat_app.send_message.side_effect = Exception('Google Chat error')
-
-        response = self.service.new_feedback(
-            company_short_name='my_company',
-            message='feedback message for testing',
-            external_user_id='flibedinsky',
-            space='spaces/AAQAupQldd4',
-            type='MESSAGE_TRIGGER',
-            rating=3
-        )
-
-        # Verify Google Chat was called
-        self.google_chat_app.send_message.assert_called_once()
-
-        # Verify error response due to Google Chat exception
-        assert 'error' in response
-        assert 'Google Chat error' in response['error']
-
-    def test_feedback_google_chat_failure_does_not_affect_save(self):
-        """Test that Google Chat failure (not exception) doesn't prevent feedback from being saved"""
-        self.profile_repo.save_feedback.return_value = UserFeedback
-
-        # Mock Google Chat failure (returns success: false, not exception)
-        self.google_chat_app.send_message.return_value = {
-            'success': False,
-            'message': 'Error al enviar mensaje'
-        }
-
-        response = self.service.new_feedback(
-            company_short_name='my_company',
-            message='feedback message for testing',
-            external_user_id='flibedinsky',
-            space='spaces/AAQAupQldd4',
-            type='MESSAGE_TRIGGER',
-            rating=4
-        )
-
-        # Verify Google Chat was called
-        self.google_chat_app.send_message.assert_called_once()
-
-        # Verify feedback was still saved successfully despite Google Chat failure
-        assert 'Feedback guardado correctamente' == response['message']
-
-    def test_feedback_message_format_with_external_user_id(self):
-        """Test the format of the Google Chat message with external_user_id"""
-        self.profile_repo.save_feedback.return_value = UserFeedback
-
-        self.service.new_feedback(
-            company_short_name='test_company',
-            message='Test feedback message',
-            external_user_id='user123',
-            space='spaces/test-space',
-            type='MESSAGE_TRIGGER',
-            rating=5
-        )
-
-        call_args = self.google_chat_app.send_message.call_args[1]['message_data']
-        expected_message = "*Nuevo feedback de test_company*:\n*Usuario:* user123\n*Mensaje:* Test feedback message\n*Calificación:* 5"
-        assert call_args['message']['text'] == expected_message
-        assert call_args['type'] == 'MESSAGE_TRIGGER'
-        assert call_args['space']['name'] == 'spaces/test-space'
-
-    def test_feedback_message_format_with_local_user_id(self):
-        """Test the format of the Google Chat message with local_user_id"""
-        self.profile_repo.save_feedback.return_value = UserFeedback
-
-        self.service.new_feedback(
-            company_short_name='test_company',
-            message='Test feedback message',
-            local_user_id=456,
-            space='spaces/test-space',
-            type='MESSAGE_TRIGGER',
-            rating=2
-        )
-
-        call_args = self.google_chat_app.send_message.call_args[1]['message_data']
-        expected_message = "*Nuevo feedback de test_company*:\n*Usuario:* 456\n*Mensaje:* Test feedback message\n*Calificación:* 2"
-        assert call_args['message']['text'] == expected_message
-        assert call_args['type'] == 'MESSAGE_TRIGGER'
-        assert call_args['space']['name'] == 'spaces/test-space'
-
-    def test_feedback_message_format_with_both_user_ids(self):
-        """Test that external_user_id takes precedence over local_user_id"""
-        self.profile_repo.save_feedback.return_value = UserFeedback
-
-        self.service.new_feedback(
-            company_short_name='test_company',
-            message='Test feedback message',
-            external_user_id='user123',
-            local_user_id=456,
-            space='spaces/test-space',
-            type='MESSAGE_TRIGGER',
-            rating=4
-        )
-
-        call_args = self.google_chat_app.send_message.call_args[1]['message_data']
-        expected_message = "*Nuevo feedback de test_company*:\n*Usuario:* user123\n*Mensaje:* Test feedback message\n*Calificación:* 4"
-        assert call_args['message']['text'] == expected_message
-        assert call_args['type'] == 'MESSAGE_TRIGGER'
-        assert call_args['space']['name'] == 'spaces/test-space'
-
-    def test_feedback_google_chat_called_before_save(self):
-        """Test that Google Chat notification is sent before saving to database"""
-        self.profile_repo.save_feedback.return_value = UserFeedback
-
-        # Track the order of calls
-        call_order = []
-
-        def mock_send_message(message_data):
-            call_order.append('google_chat')
-            return {'success': True, 'message': 'Mensaje enviado correctamente'}
-
-        def mock_save_feedback(feedback):
-            call_order.append('save_feedback')
-            return UserFeedback
-
-        self.google_chat_app.send_message.side_effect = mock_send_message
-        self.profile_repo.save_feedback.side_effect = mock_save_feedback
-
-        self.service.new_feedback(
-            company_short_name='test_company',
-            message='Test feedback message',
-            external_user_id='user123',
-            space='spaces/test-space',
-            type='MESSAGE_TRIGGER',
-            rating=3
-        )
-
-        # Verify Google Chat was called before saving
-        assert call_order == ['google_chat', 'save_feedback']
-
-    def test_feedback_with_custom_type_and_space(self):
-        """Test that custom type and space values are used correctly"""
-        self.profile_repo.save_feedback.return_value = UserFeedback
-
-        self.service.new_feedback(
-            company_short_name='test_company',
-            message='Test feedback message',
-            external_user_id='user123',
-            space='spaces/custom-space-id',
-            type='CUSTOM_TYPE',
-            rating=1
-        )
-
-        call_args = self.google_chat_app.send_message.call_args[1]['message_data']
-        assert call_args['type'] == 'CUSTOM_TYPE'
-        assert call_args['space']['name'] == 'spaces/custom-space-id'
-        assert '*Nuevo feedback de test_company*' in call_args['message']['text']
-        assert '*Calificación:* 1' in call_args['message']['text']
-
-    def test_feedback_save_feedback_called_with_rating(self):
-        """Test that save_feedback is called with the rating parameter"""
-        self.profile_repo.save_feedback.return_value = UserFeedback
-
-        self.service.new_feedback(
-            company_short_name='test_company',
-            message='Test feedback message',
-            external_user_id='user123',
-            space='spaces/test-space',
-            type='MESSAGE_TRIGGER',
-            rating=5
-        )
-
-        # Verify save_feedback was called
-        self.profile_repo.save_feedback.assert_called_once()
-
-        # Get the UserFeedback object that was passed to save_feedback
-        saved_feedback = self.profile_repo.save_feedback.call_args[0][0]
-
-        # Verify the rating was set correctly
-        assert saved_feedback.rating == 5
-        assert saved_feedback.message == 'Test feedback message'
-        assert saved_feedback.external_user_id == 'user123'
-        assert saved_feedback.company_id == self.company.id
-
-    def test_feedback_with_different_rating_values(self):
-        """Test that different rating values work correctly"""
-        self.profile_repo.save_feedback.return_value = UserFeedback
-
-        # Test with rating 1
-        response1 = self.service.new_feedback(
-            company_short_name='test_company',
-            message='Test feedback message',
-            external_user_id='user123',
-            space='spaces/test-space',
-            type='MESSAGE_TRIGGER',
-            rating=1
-        )
-        assert 'Feedback guardado correctamente' == response1['message']
-
-        # Test with rating 5
-        response2 = self.service.new_feedback(
-            company_short_name='test_company',
-            message='Test feedback message',
-            external_user_id='user123',
-            space='spaces/test-space',
-            type='MESSAGE_TRIGGER',
-            rating=5
-        )
-        assert 'Feedback guardado correctamente' == response2['message']
-
-        # Verify both calls were made
-        assert self.profile_repo.save_feedback.call_count == 2
-
-        # Verify the ratings were saved correctly
-        calls = self.profile_repo.save_feedback.call_args_list
-        assert calls[0][0][0].rating == 1
-        assert calls[1][0][0].rating == 5
-
-    def test_feedback_google_chat_message_includes_rating(self):
-        """Test that Google Chat message includes the rating in the correct format"""
-        self.profile_repo.save_feedback.return_value = UserFeedback
-
-        self.service.new_feedback(
-            company_short_name='test_company',
-            message='Test feedback message',
-            external_user_id='user123',
-            space='spaces/test-space',
-            type='MESSAGE_TRIGGER',
-            rating=4
-        )
-
-        call_args = self.google_chat_app.send_message.call_args[1]['message_data']
-        message_text = call_args['message']['text']
-
-        # Verify the rating is included in the message
-        assert '*Calificación:* 4' in message_text
-
-        # Verify the complete message format
-        expected_parts = [
-            '*Nuevo feedback de test_company*:',
-            '*Usuario:* user123',
-            '*Mensaje:* Test feedback message',
-            '*Calificación:* 4'
-        ]
-
-        for part in expected_parts:
-            assert part in message_text