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

tests/views/test_prompt_view.py

@@ -1,111 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import pytest
-from unittest.mock import MagicMock
-from flask import Flask
-from iatoolkit.views.prompt_view import PromptView
-from iatoolkit.services.prompt_manager_service import PromptService
-from iatoolkit.common.auth import IAuthentication
-
-
-class TestPromptView:
-    @staticmethod
-    def create_app():
-        """Creates a Flask app instance for testing."""
-        app = Flask(__name__)
-        app.testing = True
-        return app
-
-    @pytest.fixture(autouse=True)
-    def setup(self):
-        """Set up the test client and mock dependencies for each test."""
-        self.app = self.create_app()
-        self.client = self.app.test_client()
-        self.prompt_service = MagicMock(spec=PromptService)
-        self.iauthentication = MagicMock(spec=IAuthentication)
-
-        # Default to successful authentication
-        self.iauthentication.verify.return_value = {'success': True}
-
-        # Register the view with mocked dependencies
-        prompt_view = PromptView.as_view("prompt",
-                                         iauthentication=self.iauthentication,
-                                         prompt_service=self.prompt_service)
-        self.app.add_url_rule('/<company_short_name>/prompts',
-                              view_func=prompt_view,
-                              methods=["GET"])
-
-    def test_get_when_auth_error(self):
-        """Test response when authentication fails."""
-        self.iauthentication.verify.return_value = {
-            'success': False,
-            'error_message': 'Authentication token is invalid'
-        }
-
-        response = self.client.get('/test_company/prompts')
-
-        assert response.status_code == 401
-        assert response.json['error_message'] == 'Authentication token is invalid'
-        self.prompt_service.get_user_prompts.assert_not_called()
-
-    def test_get_when_service_returns_error(self):
-        """Test response when the prompt service returns a logical error."""
-        self.prompt_service.get_user_prompts.return_value = {
-            'error': 'Company not configured for prompts'
-        }
-
-        response = self.client.get('/test_company/prompts')
-
-        assert response.status_code == 402
-        assert response.json['error_message'] == 'Company not configured for prompts'
-        self.iauthentication.verify.assert_called_once_with('test_company')
-        self.prompt_service.get_user_prompts.assert_called_once_with('test_company')
-
-    def test_get_when_service_raises_exception(self):
-        """Test response when the prompt service raises an unhandled exception."""
-        self.prompt_service.get_user_prompts.side_effect = Exception('Unexpected database error')
-
-        response = self.client.get('/test_company/prompts')
-
-        assert response.status_code == 500
-        assert response.json['error_message'] == 'Unexpected database error'
-
-    def test_get_success(self):
-        """Test a successful request to retrieve prompts."""
-        mock_response = {
-            'message': [
-                {'prompt': 'sales_prompt', 'description': 'A prompt for sales questions'},
-                {'prompt': 'support_prompt', 'description': 'A prompt for support inquiries'}
-            ]
-        }
-        self.prompt_service.get_user_prompts.return_value = mock_response
-
-        response = self.client.get('/test_company/prompts')
-
-        assert response.status_code == 200
-        assert response.json == mock_response
-        self.iauthentication.verify.assert_called_once_with('test_company')
-        self.prompt_service.get_user_prompts.assert_called_once_with('test_company')
-
-    def test_get_success_with_empty_list(self):
-        """Test a successful request that results in an empty list of prompts."""
-        mock_response = {'message': []}
-        self.prompt_service.get_user_prompts.return_value = mock_response
-
-        response = self.client.get('/test_company/prompts')
-
-        assert response.status_code == 200
-        assert response.json == mock_response
-
-    def test_get_calls_services_with_correct_company(self):
-        """Test that services are called with the correct company name from the URL."""
-        self.prompt_service.get_user_prompts.return_value = {'message': []}
-
-        company_name = 'another-company'
-        self.client.get(f'/{company_name}/prompts')
-
-        self.iauthentication.verify.assert_called_once_with(company_name)
-        self.prompt_service.get_user_prompts.assert_called_once_with(company_name)

tests/views/test_signup_view.py

@@ -1,140 +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.signup_view import SignupView
-from iatoolkit.repositories.models import Company
-
-
-class TestSignupView:
-    @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 = SignupView.as_view("signup", profile_service=self.profile_service)
-        self.app.add_url_rule("/<company_short_name>/signup", view_func=view, methods=["GET", "POST"])
-
-    @patch("iatoolkit.views.signup_view.render_template")
-    @patch("iatoolkit.views.signup_view.URLSafeTimedSerializer")
-    def test_get_when_invalid_company(self, mock_serializer, mock_render):
-        mock_serializer.return_value.loads.return_value = "nonexistent@email.com"
-        self.profile_service.get_company_by_short_name.return_value = None
-        response = self.client.get("/test_company/signup")
-        assert response.status_code == 404
-
-    @patch("iatoolkit.views.signup_view.render_template")
-    @patch("iatoolkit.views.signup_view.URLSafeTimedSerializer")
-    def test_post_when_invalid_company(self, mock_serializer, mock_render):
-        mock_serializer.return_value.loads.return_value = "nonexistent@email.com"
-        self.profile_service.get_company_by_short_name.return_value = None
-        response = self.client.post("/test_company/signup",
-                                    data={},
-                                    content_type="application/x-www-form-urlencoded")
-
-        assert response.status_code == 404
-
-    @patch("iatoolkit.views.signup_view.render_template")
-    @patch("iatoolkit.views.signup_view.URLSafeTimedSerializer")
-    def test_get_signup_page(self, mock_serializer, mock_render_template):
-        mock_serializer.return_value.loads.return_value = "nonexistent@email.com"
-        mock_render_template.return_value = "<html><body><h1>Signup Page</h1></body></html>"
-        response = self.client.get("/test_company/signup")
-
-        assert response.status_code == 200
-
-    @patch("iatoolkit.views.signup_view.render_template")
-    @patch("iatoolkit.views.signup_view.url_for")
-    @patch("iatoolkit.views.signup_view.URLSafeTimedSerializer")
-    def test_post_with_error(self, mock_serializer, mock_url_for, mock_render_template):
-        mock_serializer.return_value.loads.return_value = "nonexistent@email.com"
-        mock_url_for.return_value = 'http://verification'
-        mock_render_template.return_value = "<html><body></body></html>"
-        self.profile_service.signup.return_value = \
-            {'error': 'user exists'}
-
-        response = self.client.post("/test_company/signup",
-                                    data={
-                                        "first_name": "Juan",
-                                        "last_name": "Perez",
-                                        "email": "test@email.com",
-                                        "password": "password123",
-                                        "confirm_password": "password123"
-                                    },
-                                    content_type="application/x-www-form-urlencoded")
-
-        assert response.status_code == 400
-
-    @patch("iatoolkit.views.signup_view.render_template")
-    @patch("iatoolkit.views.signup_view.url_for")
-    @patch("iatoolkit.views.signup_view.URLSafeTimedSerializer")
-    def test_post_when_ok(self, mock_serializer, mock_url_for, mock_render_template):
-        mock_render_template.return_value = "<html><body></body></html>"
-        mock_serializer.return_value.loads.return_value = "nonexistent@email.com"
-        mock_url_for.return_value = 'http://verification'
-        self.profile_service.signup.return_value = \
-            {"message": "User created"}
-
-        response = self.client.post("/test_company/signup",
-                                    data={
-                                        "first_name": "Juan",
-                                        "last_name": "Perez",
-                                        "email": "juan@email.com",
-                                        "password": "password123",
-                                        "confirm_password": "password123"
-                                    },
-                                    content_type="application/x-www-form-urlencoded")
-
-        assert response.status_code == 200
-        mock_render_template.assert_called_once_with(
-            "login.html",
-            company=self.test_company,
-            company_short_name='test_company',
-            alert_message="User created",
-            alert_icon='success'
-        )
-
-    @patch("iatoolkit.views.signup_view.render_template")
-    @patch("iatoolkit.views.signup_view.URLSafeTimedSerializer")
-    def test_post_unexpected_error(self, mock_serializer, mock_render_template):
-        mock_serializer.return_value.loads.side_effect = Exception('an error')
-        response = self.client.post("/test_company/signup",
-                                    data={
-                                        "first_name": "Juan",
-                                        "last_name": "Perez",
-                                        "email": "juan@email.com",
-                                        "password": "password123",
-                                        "confirm_password": "password123"
-                                    },
-                                    content_type="application/x-www-form-urlencoded")
-
-        mock_render_template.assert_called_once_with(
-            "error.html",
-            company=self.test_company,
-            company_short_name='test_company',
-            message="Ha ocurrido un error inesperado."
-        )
-        assert response.status_code == 500

tests/views/test_tasks_review_view.py

@@ -1,104 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import pytest
-from unittest.mock import MagicMock
-from flask import Flask
-from iatoolkit.repositories.profile_repo import ProfileRepo
-from iatoolkit.views.tasks_review_view import TaskReviewView
-from iatoolkit.services.tasks_service import TaskService, TaskStatus
-from iatoolkit.repositories.models import Company, ApiKey
-
-
-
-class TestTaskReviewView:
-
-    def setup_method(self):
-        self.app = Flask(__name__)
-        self.client = self.app.test_client()
-
-        self.mock_task_service = MagicMock(spec=TaskService)
-        self.mock_profile_repo = MagicMock(spec=ProfileRepo)
-
-        # Instanciamos la vista con el mock del servicio
-        self.task_review_view = TaskReviewView.as_view("tasks-review",
-                                                       task_service=self.mock_task_service,
-                                                       profile_repo=self.mock_profile_repo)
-        self.app.add_url_rule('/tasks/review/<int:task_id>', view_func=self.task_review_view, methods=["POST"])
-
-        # API Key exitosa
-        self.api_key = ApiKey(key="test_key", company_id=100)
-        self.api_key.company = Company(id=100, name="Test Company", short_name="test_company")
-        self.mock_profile_repo.get_active_api_key_entry.return_value = self.api_key
-        self.valid_header = {"Authorization": f"Bearer {self.api_key.key}"}
-
-    @pytest.mark.parametrize("missing_field", ["review_user", "approved"])
-    def test_post_when_missing_required_fields(self, missing_field):
-        payload = {
-            "review_user": "test_username",
-            "approved": True,
-            "comment": "this is a comment",
-        }
-        payload.pop(missing_field)
-
-        response = self.client.post('/tasks/review/1',
-                                    headers=self.valid_header,
-                                    json=payload)
-
-        assert response.status_code == 400
-        assert response.get_json() == {
-            "error": f"El campo {missing_field} es requerido"
-        }
-
-        self.mock_task_service.create_task.assert_not_called()
-
-    def test_post_when_internal_exception_error(self):
-        self.mock_task_service.review_task.side_effect = Exception("Internal Error")
-
-        payload = {
-            "review_user": "test_username",
-            "approved": True,
-            "comment": "this is a comment",
-        }
-
-        response = self.client.post('/tasks/review/1',
-                                    headers=self.valid_header,
-                                    json=payload)
-
-        assert response.status_code == 500
-        assert response.get_json() == {
-            "error": "Internal Error"
-        }
-
-        self.mock_task_service.review_task.assert_called_once()
-
-    def test_post_when_successful_creation(self):
-        mocked_task = MagicMock()
-        mocked_task.id = 123
-        mocked_task.status = TaskStatus.aprobada
-        self.mock_task_service.review_task.return_value = mocked_task
-
-        payload = {
-            "review_user": "test_username",
-            "approved": True,
-            "comment": "this is a comment",
-        }
-
-        response = self.client.post('/tasks/review/1',
-                                    headers=self.valid_header,
-                                    json=payload)
-
-        assert response.status_code == 200
-        assert response.get_json() == {
-            "task_id": 123,
-            "status": "aprobada"
-        }
-
-        self.mock_task_service.review_task.assert_called_once_with(
-            task_id=1,
-            review_user="test_username",
-            approved=True,
-            comment="this is a comment"
-        )

tests/views/test_tasks_view.py

@@ -1,130 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import pytest
-from unittest.mock import MagicMock
-from flask import Flask
-from iatoolkit.views.tasks_view import TaskView
-from iatoolkit.services.tasks_service import TaskService
-from iatoolkit.repositories.profile_repo import ProfileRepo
-from iatoolkit.repositories.models import Company, ApiKey
-from datetime import datetime
-
-
-class TestTaskView:
-
-    def setup_method(self):
-        self.app = Flask(__name__)
-        self.client = self.app.test_client()
-
-        # Mock del TaskService
-        self.mock_task_service = MagicMock(spec=TaskService)
-        self.mock_profile_repo = MagicMock(spec=ProfileRepo)
-
-
-        # Instanciamos la vista con el mock del servicio
-        self.task_view = TaskView.as_view("tasks",
-                                          task_service=self.mock_task_service,
-                                          profile_repo=self.mock_profile_repo)
-        self.app.add_url_rule('/tasks', view_func=self.task_view, methods=["POST"])
-
-        # API Key exitosa
-        self.api_key = ApiKey(key="test_key", company_id=100)
-        self.api_key.company = Company(id=100, name="Test Company", short_name="test_company")
-        self.mock_profile_repo.get_active_api_key_entry.return_value = self.api_key
-        self.valid_header = {"Authorization": f"Bearer {self.api_key.key}"}
-
-    @pytest.mark.parametrize("missing_field", ["company", "task_type", "client_data"])
-    def test_post_when_missing_required_fields(self, missing_field):
-        payload = {
-            "company": "test_company",
-            "task_type": "test_type",
-            "client_data": {"key": "value"},
-        }
-        payload.pop(missing_field)
-
-        response = self.client.post('/tasks',
-                                    headers=self.valid_header,
-                                    json=payload)
-
-        assert response.status_code == 400
-        assert response.get_json() == {
-            "error": f"El campo {missing_field} es requerido"
-        }
-
-        self.mock_task_service.create_task.assert_not_called()
-
-    def test_post_when_invalid_execute_at_format(self):
-        payload = {
-            "company": "test_company",
-            "task_type": "test_type",
-            "client_data": {"key": "value"},
-            "execute_at": "fecha-invalida"
-        }
-
-        response = self.client.post('/tasks',
-                                    headers=self.valid_header,
-                                    json=payload)
-
-        assert response.status_code == 400
-        assert response.get_json() == {
-            "error": "El formato de execute_at debe ser YYYY-MM-DD HH:MM:SS"
-        }
-
-        self.mock_task_service.create_task.assert_not_called()
-
-    def test_post_when_internal_exception_error(self):
-        self.mock_task_service.create_task.side_effect = Exception("Internal Error")
-
-        payload = {
-            "company": "test_company",
-            "task_type": "test_type",
-            "client_data": {"key": "value"}
-        }
-
-        response = self.client.post('/tasks',
-                                    headers=self.valid_header,
-                                    json=payload)
-
-        assert response.status_code == 500
-        assert response.get_json() == {
-            "error": "Internal Error"
-        }
-
-        self.mock_task_service.create_task.assert_called_once()
-
-    def test_post_when_successful_creation(self):
-        mocked_task = MagicMock()
-        mocked_task.id = 123
-        mocked_task.status.name = "CREATED"
-        self.mock_task_service.create_task.return_value = mocked_task
-
-        payload = {
-            "company": "test_company",
-            "company_task_id": 100,
-            "task_type": "test_type",
-            "client_data": {"key": "value"},
-            "execute_at": "2024-04-17 10:00:00"
-        }
-
-        response = self.client.post('/tasks', headers=self.valid_header,
-                                    json=payload)
-
-        assert response.status_code == 201
-        assert response.get_json() == {
-            "task_id": 123,
-            "status": "CREATED"
-        }
-
-        execute_datetime = datetime.fromisoformat(payload["execute_at"])
-
-        self.mock_task_service.create_task.assert_called_once_with(
-            company_short_name="test_company",
-            task_type_name="test_type",
-            client_data={"key": "value"},
-            company_task_id=100,
-            execute_at=execute_datetime,
-            files=[]
-        )