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

tests/views/test_history_view.py

@@ -1,336 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import pytest
-from unittest.mock import MagicMock, patch
-from flask import Flask
-from iatoolkit.views.history_view import HistoryView
-from iatoolkit.services.history_service import HistoryService
-from iatoolkit.common.auth import IAuthentication
-
-
-class TestHistoryView:
-    @staticmethod
-    def create_app():
-        app = Flask(__name__)
-        app.testing = True
-        return app
-
-    @pytest.fixture(autouse=True)
-    def setup(self):
-        self.app = self.create_app()
-        self.client = self.app.test_client()
-        self.history_service = MagicMock(spec=HistoryService)
-        self.iauthentication = MagicMock(spec=IAuthentication)
-
-        self.iauthentication.verify.return_value = {
-            'success': True,
-            'company_id': 101,
-            'external_user_id': 'test_user_id'
-        }
-
-        # register the view
-        self.history_view = HistoryView.as_view("history",
-                                          history_service=self.history_service,
-                                          iauthentication=self.iauthentication)
-        self.app.add_url_rule('/<company_short_name>/history',
-                              view_func=self.history_view,
-                              methods=["POST"])
-
-    def test_post_when_missing_data(self):
-        """Test when no JSON data is provided"""
-        response = self.client.post('/my_company/history',
-                                    json={})
-
-        assert response.status_code == 400
-        assert response.json["error_message"] == "Cuerpo de la solicitud JSON inválido o faltante"
-        self.history_service.get_history.assert_not_called()
-
-    def test_post_when_invalid_json(self):
-        """Test when invalid JSON is provided"""
-        response = self.client.post('/my_company/history',
-                                    data='invalid json',
-                                    content_type='application/json')
-
-        assert response.status_code == 400
-        assert response.json["error_message"] == "Cuerpo de la solicitud JSON inválido o faltante"
-        self.history_service.get_history.assert_not_called()
-
-    def test_post_when_auth_error(self):
-        """Test when authentication fails"""
-        self.iauthentication.verify.return_value = {
-            'success': False,
-            'error_message': 'Usuario no autenticado'
-        }
-
-        response = self.client.post('/my_company/history',
-                                    json={'external_user_id': 'flibe'})
-
-        assert response.status_code == 401
-        assert response.json["error_message"] == 'Usuario no autenticado'
-        self.history_service.get_history.assert_not_called()
-
-    def test_post_when_missing_external_user_id(self):
-        """Test when external_user_id is missing"""
-        response = self.client.post('/my_company/history',
-                                    json={})
-
-        assert response.status_code == 400
-        assert response.json["error_message"] == "Cuerpo de la solicitud JSON inválido o faltante"
-        self.history_service.get_history.assert_not_called()
-
-    def test_post_when_service_error(self):
-        """Test when service returns an error"""
-        self.history_service.get_history.return_value = {
-            'error': 'Error al obtener historial'
-        }
-
-        response = self.client.post('/my_company/history',
-                                    json={'external_user_id': 'flibe'})
-
-        assert response.status_code == 402
-        assert response.json == {'error_message': 'Error al obtener historial'}
-
-    def test_post_when_service_exception(self):
-        """Test when service raises an exception"""
-        self.history_service.get_history.side_effect = Exception('Service error')
-
-        response = self.client.post('/my_company/history',
-                                    json={'external_user_id': 'flibe'})
-
-        assert response.status_code == 500
-        assert response.json["error_message"] == 'Service error'
-
-    def test_post_when_ok_with_external_user_id(self):
-        """Test successful request with external_user_id"""
-        mock_history = {
-            'success': True,
-            'history': [
-                {
-                    'id': 1,
-                    'question': 'Test question',
-                    'answer': 'Test answer',
-                    'created_at': '2024-01-15T10:30:00Z'
-                }
-            ],
-            'count': 1
-        }
-        self.history_service.get_history.return_value = mock_history
-
-        response = self.client.post('/my_company/history',
-                                    json={'external_user_id': 'flibe'})
-
-        assert response.status_code == 200
-        assert response.json == mock_history
-
-        # Verify service was called correctly
-        self.history_service.get_history.assert_called_once_with(
-            company_short_name='my_company',
-            external_user_id='flibe',
-            local_user_id=0
-        )
-
-    def test_post_when_ok_with_local_user_id(self):
-        """Test successful request with local_user_id"""
-        mock_history = {
-            'success': True,
-            'history': [
-                {
-                    'id': 1,
-                    'question': 'Test question',
-                    'answer': 'Test answer',
-                    'created_at': '2024-01-15T10:30:00Z'
-                }
-            ],
-            'count': 1
-        }
-
-        self.history_service.get_history.return_value = mock_history
-
-        response = self.client.post('/my_company/history',
-                                    json={
-                                        'external_user_id': 'flibe',
-                                        'local_user_id': 123
-                                    })
-
-        assert response.status_code == 200
-        assert response.json == mock_history
-
-        # Verify service was called correctly
-        self.history_service.get_history.assert_called_once_with(
-            company_short_name='my_company',
-            external_user_id='flibe',
-            local_user_id=123
-        )
-
-    def test_post_when_ok_with_both_user_ids(self):
-        """Test successful request with both user IDs"""
-        mock_history = {
-            'success': True,
-            'history': [
-                {
-                    'id': 1,
-                    'question': 'Test question',
-                    'answer': 'Test answer',
-                    'created_at': '2024-01-15T10:30:00Z'
-                }
-            ],
-            'count': 1
-        }
-
-        self.history_service.get_history.return_value = mock_history
-
-        response = self.client.post('/my_company/history',
-                                    json={
-                                        'external_user_id': 'flibe',
-                                        'local_user_id': 456
-                                    })
-
-        assert response.status_code == 200
-        assert response.json == mock_history
-
-        # Verify service was called correctly
-        self.history_service.get_history.assert_called_once_with(
-            company_short_name='my_company',
-            external_user_id='flibe',
-            local_user_id=456
-        )
-
-    def test_post_with_empty_history(self):
-        """Test when service returns empty history"""
-        mock_history = {
-            'success': True,
-            'history': [],
-            'count': 0
-        }
-
-        self.history_service.get_history.return_value = mock_history
-
-        response = self.client.post('/my_company/history',
-                                    json={'external_user_id': 'flibe'})
-
-        assert response.status_code == 200
-        assert response.json == mock_history
-        assert response.json['count'] == 0
-
-    def test_post_with_large_history(self):
-        """Test with large history response"""
-        mock_history = {
-            'success': True,
-            'history': [
-                {
-                    'id': i,
-                    'question': f'Question {i}',
-                    'answer': f'Answer {i}',
-                    'created_at': '2024-01-15T10:30:00Z'
-                } for i in range(1, 11)
-            ],
-            'count': 10
-        }
-
-        self.history_service.get_history.return_value = mock_history
-
-        response = self.client.post('/my_company/history',
-                                    json={'external_user_id': 'flibe'})
-
-        assert response.status_code == 200
-        assert response.json == mock_history
-        assert response.json['count'] == 10
-        assert len(response.json['history']) == 10
-
-    @patch("iatoolkit.views.history_view.render_template")
-    def test_post_exception_with_local_user_id(self, mock_render_template):
-        """Test exception handling when local_user_id is present"""
-        mock_render_template.return_value = "<html><body>Error</body></html>"
-        self.history_service.get_history.side_effect = Exception('Service error')
-
-        response = self.client.post('/my_company/history',
-                                    json={
-                                        'external_user_id': 'flibe',
-                                        'local_user_id': 123
-                                    })
-
-        assert response.status_code == 500
-        mock_render_template.assert_called_once_with(
-            "error.html",
-            message="Ha ocurrido un error inesperado."
-        )
-
-    def test_post_exception_without_local_user_id(self):
-        """Test exception handling when local_user_id is not present"""
-        self.history_service.get_history.side_effect = Exception('Service error')
-
-        response = self.client.post('/my_company/history',
-                                    json={'external_user_id': 'flibe'})
-
-        assert response.status_code == 500
-        assert response.json["error_message"] == 'Service error'
-
-    def test_post_authentication_verification_called(self):
-        """Test that authentication verification is called correctly"""
-        mock_history = {
-            'success': True,
-            'history': [],
-            'count': 0
-        }
-
-        self.history_service.get_history.return_value = mock_history
-
-        response = self.client.post('/my_company/history',
-                                    json={'external_user_id': 'test_user'})
-
-        assert response.status_code == 200
-
-        # Verify authentication was called correctly
-        self.iauthentication.verify.assert_called_once_with('my_company', 'test_user')
-
-    def test_post_different_company(self):
-        """Test with different company short name"""
-        mock_history = {
-            'success': True,
-            'history': [],
-            'count': 0
-        }
-
-        self.history_service.get_history.return_value = mock_history
-
-        response = self.client.post('/test_company/history',
-                                    json={'external_user_id': 'flibe'})
-
-        assert response.status_code == 200
-
-        # Verify service was called with correct company
-        self.history_service.get_history.assert_called_once_with(
-            company_short_name='test_company',
-            external_user_id='flibe',
-            local_user_id=0
-        )
-
-    def test_post_with_additional_fields_ignored(self):
-        """Test that additional fields in JSON are ignored"""
-        mock_history = {
-            'success': True,
-            'history': [],
-            'count': 0
-        }
-
-        self.history_service.get_history.return_value = mock_history
-
-        response = self.client.post('/my_company/history',
-                                    json={
-                                        'external_user_id': 'flibe',
-                                        'local_user_id': 123,
-                                        'extra_field': 'should_be_ignored',
-                                        'another_field': 456
-                                    })
-
-        assert response.status_code == 200
-
-        # Verify only expected fields are passed to service
-        self.history_service.get_history.assert_called_once_with(
-            company_short_name='my_company',
-            external_user_id='flibe',
-            local_user_id=123
-        )

tests/views/test_home_view.py

@@ -1,61 +0,0 @@
-import pytest
-from flask import Flask
-from unittest.mock import MagicMock, patch
-import os
-
-# Asegúrate de que las importaciones sean correctas y existan
-from iatoolkit.views.home_view import HomeView
-from iatoolkit.services.profile_service import ProfileService
-from iatoolkit.repositories.models import Company
-
-
-# Ya no necesitamos JWTService, ChatTokenRequestView, etc.
-
-class TestHomeView:
-    @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 el mock 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='a company', short_name='test_company')
-        self.profile_service.get_companies.return_value = [self.test_company]
-
-        # Registrar únicamente la vista que estamos probando.
-        # No necesitamos registrar las otras vistas que han sido eliminadas.
-        view = HomeView.as_view("home", profile_service=self.profile_service)
-        self.app.add_url_rule("/", view_func=view, methods=["GET"])
-
-    @patch("iatoolkit.views.home_view.render_template")
-    @patch.dict(os.environ, {"IATOOLKIT_API_KEY": "una_api_key_de_prueba_segura"})
-    def test_get_home_page(self, mock_render_template):
-        """
-        Prueba que la página de inicio se renderice correctamente sin los parámetros obsoletos.
-        """
-        mock_render_template.return_value = "<html><body><h1>Home Page</h1></body></html>"
-
-        # Ya no necesitamos el contexto de la petición para generar las URLs
-        response = self.client.get("/")
-
-        assert response.status_code == 200
-        assert b"<h1>Home Page</h1>" in response.data
-
-        # La aserción ahora debe reflejar los argumentos actuales de render_template en HomeView
-        mock_render_template.assert_called_once_with(
-            "home.html",
-            companies=[self.test_company],
-            is_mobile=False,
-            alert_icon=None,
-            alert_message=None,
-            api_key="una_api_key_de_prueba_segura",
-            # Hemos eliminado los siguientes parámetros obsoletos:
-            # chat_token_request_url=...
-            # public_chat_url_template=...
-        )

tests/views/test_llm_query_view.py

@@ -1,154 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import pytest
-from unittest.mock import MagicMock, patch
-from flask import Flask
-from iatoolkit.repositories.models import ApiKey, Company
-from iatoolkit.services.query_service import QueryService
-from iatoolkit.views.llmquery_view import LLMQueryView
-from datetime import datetime, timezone
-from iatoolkit.common.session_manager import SessionManager
-from iatoolkit.common.auth import IAuthentication
-
-class TestLLMQueryView:
-    @staticmethod
-    def create_app():
-        """Configura la aplicación Flask para pruebas."""
-        app = Flask(__name__)
-        app.testing = True
-        app.config['TESTING'] = True
-        app.config['SECRET_KEY'] = 'test_key'
-
-        return app
-
-    @pytest.fixture(autouse=True)
-    def setup(self):
-        self.app = self.create_app()
-        self.client = self.app.test_client()
-        self.query_service = MagicMock(spec=QueryService)
-        self.iauthentication = MagicMock(spec=IAuthentication)
-
-        self.iauthentication.verify.return_value = {
-            'success': True,
-            'company_id': 101,
-            'external_user_id': 'test_user_id'
-        }
-
-        self.test_data = {
-            "question": "¿Pregunta con error?",
-            "files": []
-        }
-
-        @self.app.route('/login')
-        def login():
-            return "Login Page", 200
-
-        # Configurar la vista
-        view = LLMQueryView.as_view('llm_query',
-                                    query_service=self.query_service,
-                                    iauthentication=self.iauthentication)
-        self.app.add_url_rule('/<company_short_name>/query', view_func=view)
-
-        self.query_service.llm_query.return_value = {
-            "answer": "Respuesta exitosa",
-            "aditional_data": {}
-        }
-
-        # Mock values
-        self.api_key = ApiKey(key="test_key", company_id=100)
-        self.api_key.company = Company(id=100, name="Test Company", short_name="test_company")
-
-        mock_session_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_session_values.get(key, default)
-
-        with patch('iatoolkit.common.auth.SessionManager', new=mock_session_manager):
-            with self.app.test_request_context():  # Necesario para Flask
-                yield
-
-    def test_post_success(self):
-        api_data = {
-            "question": "¿Cuál es el significado de la vida?",
-            "external_user_id": "test_user_id",
-            "files": ["archivo1.txt", "archivo2.txt"]
-        }
-
-        # Realizar la solicitud
-        response = self.client.post(
-            '/test_company/query',
-            json=api_data
-        )
-
-        # Verificaciones
-        assert response.status_code == 200
-        assert response.json['answer'] == "Respuesta exitosa"
-
-        self.query_service.llm_query.assert_called_once_with(
-            company_short_name='test_company',
-            local_user_id=None,
-            external_user_id='test_user_id',
-            question=api_data["question"],
-            prompt_name= None,
-            client_data={},
-            files=api_data["files"]
-        )
-
-
-    def test_post_when_missing_data(self):
-        response = self.client.post(
-            '/test_company/query',
-            json={}
-        )
-
-        assert response.status_code == 400
-        assert response.json["error_message"] == "Cuerpo de la solicitud JSON inválido o faltante"
-
-
-    def test_post_when_auth_error(self):
-        self.iauthentication.verify.return_value = {'error_message': 'error in authentication'}
-        response = self.client.post(
-            '/test_company/query',
-            json=self.test_data
-        )
-
-        assert response.status_code == 401
-        assert response.json["error_message"] == 'error in authentication'
-
-
-    def test_post_service_error(self):
-        """Prueba el manejo de errores del servicio."""
-        self.query_service.llm_query.return_value = {
-            "error": True,
-            "error_message": "Error de proceso"
-        }
-
-        response = self.client.post(
-            '/test_company/query',
-            json=self.test_data
-        )
-
-        assert response.status_code == 401
-        assert response.json["error_message"] == "Error de proceso"
-
-    @patch("iatoolkit.views.llmquery_view.render_template")
-    def test_post_unexpected_error(self, mock_render):
-        self.query_service.llm_query.side_effect = Exception("Error inesperado")
-
-        test_data = {
-            "question": "¿Pregunta con error?",
-            "files": []
-        }
-
-        response = self.client.post('/test_company/query',json=test_data)
-        assert response.status_code == 500

tests/views/test_login_view.py

@@ -1,114 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import pytest
-from flask import Flask, jsonify
-from unittest.mock import MagicMock, patch
-from iatoolkit.services.profile_service import ProfileService
-from iatoolkit.views.login_view import LoginView
-from iatoolkit.repositories.models import Company
-
-
-class TestLoginView:
-    @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 el mock 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 = LoginView.as_view("login", profile_service=self.profile_service)
-        self.app.add_url_rule("/<company_short_name>/login", view_func=view, methods=["GET", "POST"])
-
-        # Registrar un endpoint temporal para el test
-        @self.app.route("/test_company/chat")
-        def chat():
-            return jsonify({"message": "Bienvenido al chat"}), 200
-
-    @patch("iatoolkit.views.login_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/login")
-        assert response.status_code == 404
-
-        response = self.client.post("/test_company/login",
-                                    data={"email": "fer", "password": "123456"},
-                                    content_type="application/x-www-form-urlencoded")
-
-        assert response.status_code == 404
-
-    @patch("iatoolkit.views.login_view.render_template")
-    def test_get_login_page(self, mock_render_template):
-        mock_render_template.return_value = "<html><body><h1>Login Page</h1></body></html>"
-        response = self.client.get("/test_company/login")
-
-        mock_render_template.assert_called_once_with(
-            "login.html",
-            company=self.test_company,
-            company_short_name='test_company'
-        )
-
-        assert response.status_code == 200
-        assert b"<h1>Login Page</h1>" in response.data
-
-    @patch("iatoolkit.views.login_view.render_template")
-    def test_post_with_error(self, mock_render_template):
-        self.profile_service.login.return_value = {'error': 'login error'}
-        mock_render_template.return_value = "<html><body><h1>Login Page</h1></body></html>"
-        response = self.client.post("/test_company/login",
-                                    data={"email": "fer", "password": "123456"},
-                                    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',
-            form_data={"email": "fer", "password": "123456"},
-            alert_message='login error'
-        )
-        assert response.status_code == 400
-
-    def test_post_successful_login(self):
-        self.profile_service.login.return_value = {"message": "Login exitoso"}
-        response = self.client.post("/test_company/login",
-                                    data={"email": "test@email.com", "password": "password"},
-                                    content_type="application/x-www-form-urlencoded")
-
-        assert response.status_code == 302  # Redirección exitosa
-        assert response.location == "/test_company/chat?company_short_name=test_company"
-
-
-    @patch("iatoolkit.views.login_view.render_template")
-    def test_post_unexpected_error(self, mock_render_template):
-        """Prueba que se maneje correctamente un error inesperado."""
-        self.profile_service.login.side_effect = Exception("Unexpected error")
-        mock_render_template.return_value = "<html><body><h1>Error Page</h1></body></html>"
-        response = self.client.post("/test_company/login",
-                                    data={"email": "test@mail.com", "password": "any"},
-                                    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