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

tests/views/test_download_file_view.py

@@ -1,149 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-import os
-import shutil
-import tempfile
-from unittest.mock import MagicMock, patch
-
-import pytest
-from flask import Flask, jsonify
-
-from iatoolkit.common.auth import IAuthentication
-from iatoolkit.repositories.models import Company
-from iatoolkit.services.excel_service import ExcelService
-from iatoolkit.services.profile_service import ProfileService
-from iatoolkit.views.download_file_view import DownloadFileView
-
-
-class TestDownloadFileView:
-    @pytest.fixture(autouse=True)
-    def setup(self):
-        self.app = Flask(__name__)
-        self.app.testing = True
-
-        # Create a real temporary directory for static/temp
-        self.temp_dir_base = tempfile.mkdtemp()
-        self.app.root_path = self.temp_dir_base
-        temp_dir_path = os.path.join(self.app.root_path, 'static', 'temp')
-        os.makedirs(temp_dir_path)
-
-        # Create a real test file
-        self.test_filename = 'test_file.xlsx'
-        self.test_file_path = os.path.join(temp_dir_path, self.test_filename)
-        self.test_content = b'test file content'
-        with open(self.test_file_path, 'wb') as f:
-            f.write(self.test_content)
-
-        # Mocks of services
-        self.iauthentication = MagicMock(spec=IAuthentication)
-        self.profile_service = MagicMock(spec=ProfileService)
-        self.excel_service = MagicMock(spec=ExcelService)
-
-        # Default mock configuration for successful case
-        self.iauthentication.verify.return_value = {'success': True}
-        self.test_company = Company(id=1, name="Test Company", short_name="test_company")
-        self.profile_service.get_company_by_short_name.return_value = self.test_company
-        self.excel_service.validate_file_access.return_value = None
-
-        # Inject mocks and register the route
-        view = DownloadFileView.as_view(
-            'download_file',
-            iauthentication=self.iauthentication,
-            profile_service=self.profile_service,
-            excel_service=self.excel_service,
-        )
-        self.app.add_url_rule(
-            '/<string:company_short_name>/<string:external_user_id>/download-file/<path:filename>',
-            view_func=view
-        )
-
-        self.client = self.app.test_client()
-
-        yield
-
-        # Cleanup after test
-        shutil.rmtree(self.temp_dir_base)
-
-    def test_successful_download(self):
-        with self.app.app_context():
-            response = self.client.get(f'/test_company/user_123/download-file/{self.test_filename}')
-
-        assert response.status_code == 200
-        assert response.data == self.test_content
-        assert response.headers['Content-Disposition'] == f'attachment; filename={self.test_filename}'
-
-        self.iauthentication.verify.assert_called_once_with('test_company', body_external_user_id='user_123')
-        self.profile_service.get_company_by_short_name.assert_called_once_with('test_company')
-        self.excel_service.validate_file_access.assert_called_once_with(self.test_filename)
-
-    def test_missing_external_user_id(self):
-        # Test with empty external_user_id
-        with self.app.app_context():
-            response = self.client.get('/test_company//download-file/file.xlsx')
-
-        view = DownloadFileView(
-            iauthentication=self.iauthentication,
-            profile_service=self.profile_service,
-            excel_service=self.excel_service
-        )
-
-        with self.app.test_request_context():
-            response = view.get('test_company', '', 'file.xlsx')
-
-        assert response[1] == 400
-        data = response[0].get_json()
-        assert data['error'] == 'Falta external_user_id'
-
-    def test_authentication_failure(self):
-        self.iauthentication.verify.return_value = {'success': False, 'error': 'Token inválido'}
-
-        with self.app.app_context():
-            response = self.client.get(f'/test_company/user_123/download-file/{self.test_filename}')
-
-        assert response.status_code == 401
-        data = response.get_json()
-        assert data['success'] is False
-        assert data['error'] == 'Token inválido'
-
-    def test_company_not_found(self):
-        self.profile_service.get_company_by_short_name.return_value = None
-
-        with self.app.app_context():
-            response = self.client.get(f'/test_company/user_123/download-file/{self.test_filename}')
-
-        assert response.status_code == 404
-        data = response.get_json()
-        assert data['error'] == 'Empresa no encontrada'
-
-    def test_file_validation_error(self):
-        with self.app.app_context():
-            self.excel_service.validate_file_access.return_value = (jsonify({"error": "Acceso denegado"}), 403)
-            response = self.client.get('/test_company/user_123/download-file/unauthorized_file.xlsx')
-
-        assert response.status_code == 403
-        data = response.get_json()
-        assert data['error'] == 'Acceso denegado'
-
-    def test_file_not_found_on_disk(self):
-        with self.app.app_context():
-            response = self.client.get('/test_company/user_123/download-file/non_existent_file.xlsx')
-
-        assert response.status_code == 500
-        data = response.get_json()
-        assert data['error'] == 'Error descargando archivo'
-
-    @patch('iatoolkit.views.download_file_view.logging')
-    def test_logging_on_success_and_error(self, mock_logging):
-        with self.app.app_context():
-            # Success case
-            self.client.get(f'/test_company/user_123/download-file/{self.test_filename}')
-            mock_logging.info.assert_called_with(f'Archivo descargado via API: {self.test_filename}')
-
-            # Error case
-            self.client.get('/test_company/user_123/download-file/non_existent_file.xlsx')
-            assert mock_logging.error.call_count == 1
-            args, _ = mock_logging.error.call_args
-            assert 'Error descargando archivo non_existent_file.xlsx' in args[0]

tests/views/test_external_chat_login_view.py

@@ -1,120 +0,0 @@
-import pytest
-from flask import Flask
-from unittest.mock import MagicMock, patch
-from iatoolkit.views.external_chat_login_view import ExternalChatLoginView
-from iatoolkit.services.profile_service import ProfileService
-from iatoolkit.services.query_service import QueryService
-from iatoolkit.services.prompt_manager_service import PromptService
-from iatoolkit.services.jwt_service import JWTService  # <-- Importar JWTService
-from iatoolkit.common.auth import IAuthentication
-from iatoolkit.repositories.models import Company
-
-
-# --- Constantes para los Tests ---
-MOCK_COMPANY_SHORT_NAME = "test-comp"
-MOCK_EXTERNAL_USER_ID = "ext-user-123"
-MOCK_API_KEY = "super-secret-api-key"
-MOCK_JWT_TOKEN = "a-fake-but-valid-jwt-token"
-
-
-class TestExternalChatLoginView:
-
-    @pytest.fixture(autouse=True)
-    def setup_method(self):
-        """Configura la aplicación Flask y los mocks para cada test."""
-        self.app = Flask(__name__)
-        self.app.testing = True
-
-        # Mocks de todos los servicios inyectados
-        self.mock_profile_service = MagicMock(spec=ProfileService)
-        self.mock_query_service = MagicMock(spec=QueryService)
-        self.mock_prompt_service = MagicMock(spec=PromptService)
-        self.mock_iauthentication = MagicMock(spec=IAuthentication)
-        self.mock_jwt_service = MagicMock(spec=JWTService)
-
-        # Configurar el mock de la compañía que se devolverá
-        self.mock_company = Company(id=1, name="Test Company", short_name=MOCK_COMPANY_SHORT_NAME)
-        self.mock_profile_service.get_company_by_short_name.return_value = self.mock_company
-
-        # Registrar la vista en la app de Flask con TODAS las dependencias
-        view_func = ExternalChatLoginView.as_view(
-            'external_chat_login',
-            profile_service=self.mock_profile_service,
-            query_service=self.mock_query_service,
-            prompt_service=self.mock_prompt_service,
-            iauthentication=self.mock_iauthentication,
-            jwt_service=self.mock_jwt_service  # <-- 2. Inyectar el mock de JWTService
-        )
-
-        self.app.add_url_rule('/<company_short_name>/chat_login', view_func=view_func, methods=['POST'])
-        self.client = self.app.test_client()
-
-    def test_login_success(self):
-        """
-        Prueba el flujo exitoso, incluyendo la generación del JWT.
-        """
-        # Configurar mocks para el caso de éxito
-        self.mock_iauthentication.verify.return_value = {"success": True}
-        self.mock_prompt_service.get_user_prompts.return_value = []
-        # 3. Configurar el mock para que devuelva un token
-        self.mock_jwt_service.generate_chat_jwt.return_value = MOCK_JWT_TOKEN
-
-        with patch('iatoolkit.views.external_chat_login_view.render_template') as mock_render:
-            mock_render.return_value = "<html>Chat Page</html>"
-
-            response = self.client.post(
-                f'/{MOCK_COMPANY_SHORT_NAME}/chat_login',
-                headers={'Authorization': f'Bearer {MOCK_API_KEY}'},
-                json={'external_user_id': MOCK_EXTERNAL_USER_ID}
-            )
-
-        # Verificar que la respuesta es exitosa
-        assert response.status_code == 200
-        assert response.data == b"<html>Chat Page</html>"
-
-        # Verificar que se llamó a la autenticación
-        self.mock_iauthentication.verify.assert_called_once_with(
-            MOCK_COMPANY_SHORT_NAME,
-            body_external_user_id=MOCK_EXTERNAL_USER_ID
-        )
-
-        # 4. Verificar que se intentó generar el JWT con los datos correctos
-        self.mock_jwt_service.generate_chat_jwt.assert_called_once_with(
-            company_id=self.mock_company.id,
-            company_short_name=self.mock_company.short_name,
-            external_user_id=MOCK_EXTERNAL_USER_ID,
-            expires_delta_seconds=3600 * 8
-        )
-
-        # Verificar que se inicializó el contexto y se obtuvieron los prompts
-        self.mock_query_service.llm_init_context.assert_called_once()
-        self.mock_prompt_service.get_user_prompts.assert_called_once()
-
-        # 5. Verificar que se renderizó la plantilla con TODOS los datos correctos
-        mock_render.assert_called_once()
-        call_kwargs = mock_render.call_args[1]
-        assert call_kwargs['company_short_name'] == MOCK_COMPANY_SHORT_NAME
-        assert call_kwargs['external_user_id'] == MOCK_EXTERNAL_USER_ID
-        assert call_kwargs['auth_method'] == 'jwt'
-        assert call_kwargs['session_jwt'] == MOCK_JWT_TOKEN  # <-- Verificar que el token se pasa
-
-    def test_login_fails_if_jwt_generation_fails(self):
-        """
-        Prueba que la vista maneja un error si el JWTService no puede generar un token.
-        """
-        self.mock_iauthentication.verify.return_value = {"success": True}
-        # Simular fallo en la generación del token
-        self.mock_jwt_service.generate_chat_jwt.return_value = None
-
-        response = self.client.post(
-            f'/{MOCK_COMPANY_SHORT_NAME}/chat_login',
-            headers={'Authorization': f'Bearer {MOCK_API_KEY}'},
-            json={'external_user_id': MOCK_EXTERNAL_USER_ID}
-        )
-
-        # La vista debería devolver un error 500
-        assert response.status_code == 500
-        assert response.is_json
-        assert 'Error interno' in response.json['error']
-
-    # ... (el resto de los tests, como el de fallo de autenticación, permanecen igual y deberían seguir funcionando) ...

tests/views/test_external_login_view.py

@@ -1,102 +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.common.auth import IAuthentication
-from iatoolkit.views.external_login_view import ExternalLoginView
-from iatoolkit.services.query_service import QueryService
-
-
-class TestExternalLoginView:
-    @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.iauthentication = MagicMock(spec=IAuthentication)
-        self.query_service = MagicMock(spec=QueryService)
-
-        self.iauthentication.verify.return_value = {"success": True}
-
-        # Registrar la vista
-        view = ExternalLoginView.as_view("external_login", 
-                                         query_service=self.query_service,
-                                        iauthentication=self.iauthentication)
-        self.app.add_url_rule("/<company_short_name>/external_login/<external_user_id>", 
-                             view_func=view, methods=["GET"])
-
-    def test_get_with_valid_parameters(self):
-        """Test que verifica que la vista funciona con parámetros válidos"""
-        response = self.client.get("/test_company/external_login/user123")
-
-        assert response.status_code == 200
-        self.iauthentication.verify.assert_called_once_with("test_company", "user123")
-        self.query_service.llm_init_context.assert_called_once_with(
-            company_short_name="test_company",
-            external_user_id="user123"
-        )
-
-    def test_get_with_authentication_failure(self):
-        """Test que verifica el manejo de fallos de autenticación"""
-        self.iauthentication.verify.return_value = {"success": False, "error": "Invalid credentials"}
-
-        response = self.client.get("/test_company/external_login/user123")
-
-        assert response.status_code == 401
-        assert b"Invalid credentials" in response.data
-
-    def test_get_with_service_exception(self):
-        """Test que verifica el manejo de excepciones del servicio"""
-        self.query_service.llm_init_context.side_effect = Exception("Service error")
-
-        response = self.client.get("/test_company/external_login/user123")
-
-        assert response.status_code == 500
-        assert b"Service error" in response.data
-
-    def test_get_with_different_company_and_user(self):
-        """Test que verifica que funciona con diferentes combinaciones de company y user"""
-        response = self.client.get("/my_company/external_login/employee456")
-
-        assert response.status_code == 200
-        self.iauthentication.verify.assert_called_once_with("my_company", "employee456")
-        self.query_service.llm_init_context.assert_called_once_with(
-            company_short_name="my_company",
-            external_user_id="employee456"
-        )
-
-    def test_get_with_special_characters_in_parameters(self):
-        """Test que verifica el manejo de caracteres especiales en los parámetros"""
-        response = self.client.get("/test-company/external_login/user-123")
-
-        assert response.status_code == 200
-        self.iauthentication.verify.assert_called_once_with("test-company", "user-123")
-        self.query_service.llm_init_context.assert_called_once_with(
-            company_short_name="test-company",
-            external_user_id="user-123"
-        )
-
-    @patch('iatoolkit.views.external_login_view.logging')
-    def test_get_logs_exception_when_service_fails(self, mock_logging):
-        """Test que verifica que se registra la excepción cuando falla el servicio"""
-        self.query_service.llm_init_context.side_effect = Exception("Database connection failed")
-
-        response = self.client.get("/test_company/external_login/user123")
-
-        assert response.status_code == 500
-        mock_logging.exception.assert_called_once()
-        # Verificar que el mensaje de log contiene la información correcta
-        call_args = mock_logging.exception.call_args[0][0]
-        assert "test_company" in call_args
-        assert "Database connection failed" in call_args

tests/views/test_file_store_view.py

@@ -1,128 +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.file_store_view import FileStoreView
-from iatoolkit.services.load_documents_service import LoadDocumentsService
-from iatoolkit.repositories.profile_repo import ProfileRepo
-import base64
-
-
-class TestFileStoreView:
-
-    def setup_method(self):
-        self.app = Flask(__name__)
-        self.client = self.app.test_client()
-
-        # Mock the services
-        self.mock_doc_service = MagicMock(spec=LoadDocumentsService)
-        self.mock_profile_repo = MagicMock(spec=ProfileRepo)
-
-        # Instantiate the view with mocked services
-        self.file_store_view = FileStoreView.as_view("load",
-                                                    doc_service=self.mock_doc_service,
-                                                    profile_repo=self.mock_profile_repo)
-        self.app.add_url_rule('/load', view_func=self.file_store_view, methods=["POST"])
-
-    @pytest.mark.parametrize("missing_field", ["company", "filename", "content"])
-    def test_post_when_missing_required_fields(self, missing_field):
-        payload = {
-            "company": "test_company",
-            "filename": "test_file.txt",
-            "content": base64.b64encode(b"test content").decode('utf-8'),
-            "metadata": {"key": "value"}
-        }
-        payload.pop(missing_field)
-
-        response = self.client.post('/load', json=payload)
-
-        assert response.status_code == 400
-        assert response.get_json() == {
-            "error": f"El campo {missing_field} es requerido"
-        }
-
-        self.mock_doc_service.load_file_callback.assert_not_called()
-
-    def test_post_when_company_not_found(self):
-        # Mock the profile repo to return None for the company
-        self.mock_profile_repo.get_company_by_short_name.return_value = None
-
-        payload = {
-            "company": "nonexistent_company",
-            "filename": "test_file.txt",
-            "content": base64.b64encode(b"test content").decode('utf-8'),
-            "metadata": {"key": "value"}
-        }
-
-        response = self.client.post('/load', json=payload)
-
-        assert response.status_code == 400
-        assert response.get_json() == {
-            "error": "La empresa nonexistent_company no existe"
-        }
-
-        self.mock_profile_repo.get_company_by_short_name.assert_called_once_with("nonexistent_company")
-        self.mock_doc_service.load_file_callback.assert_not_called()
-
-    def test_post_when_internal_exception_error(self):
-        # Mock the profile repo to return a company
-        mock_company = MagicMock()
-        self.mock_profile_repo.get_company_by_short_name.return_value = mock_company
-
-        # Mock the doc service to raise an exception
-        self.mock_doc_service.load_file_callback.side_effect = Exception("Internal Error")
-
-        payload = {
-            "company": "test_company",
-            "filename": "test_file.txt",
-            "content": base64.b64encode(b"test content").decode('utf-8'),
-            "metadata": {"key": "value"}
-        }
-
-        response = self.client.post('/load', json=payload)
-
-        assert response.status_code == 500
-        response_json = response.get_json()
-        assert response_json is not None, "Expected JSON response, got None"
-
-        assert "error" in response_json
-        assert response_json["error"] == "Internal Error"
-
-        self.mock_profile_repo.get_company_by_short_name.assert_called_once_with("test_company")
-        self.mock_doc_service.load_file_callback.assert_called_once()
-
-    def test_post_when_successful_file_storage(self):
-        # Mock the profile repo to return a company
-        mock_company = MagicMock()
-        self.mock_profile_repo.get_company_by_short_name.return_value = mock_company
-
-        # Mock the document returned by the service
-        mock_document = MagicMock()
-        mock_document.id = 123
-        self.mock_doc_service.load_file_callback.return_value = mock_document
-
-        payload = {
-            "company": "test_company",
-            "filename": "test_file.txt",
-            "content": base64.b64encode(b"test content").decode('utf-8'),
-            "metadata": {"key": "value"}
-        }
-
-        response = self.client.post('/load', json=payload)
-
-        assert response.status_code == 200
-        assert response.get_json() == {
-            "document_id": 123
-        }
-
-        self.mock_profile_repo.get_company_by_short_name.assert_called_once_with("test_company")
-        self.mock_doc_service.load_file_callback.assert_called_once_with(
-            filename="test_file.txt",
-            content=b"test content",
-            company=mock_company,
-            context={'metadata':{"key": "value"}}
-        )

tests/views/test_forgot_password_view.py

@@ -1,142 +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.repositories.models import Company
-from iatoolkit.views.forgot_password_view import ForgotPasswordView
-import os
-
-
-class TestForgotPasswordView:
-    @classmethod
-    def setup_class(cls):
-        cls.patcher = patch.dict(os.environ, {"PASS_RESET_KEY": "mocked_reset_key"})
-        cls.patcher.start()
-
-    @classmethod
-    def teardown_class(cls):
-        cls.patcher.stop()
-
-    @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 = ForgotPasswordView.as_view("forgot_password", profile_service=self.profile_service)
-        self.app.add_url_rule("/<company_short_name>/forgot_password", view_func=view, methods=["GET", "POST"])
-
-    @patch("iatoolkit.views.forgot_password_view.render_template")
-    def test_get_when_invalid_company(self, mock_render):
-        self.profile_service.get_company_by_short_name.return_value = None
-        response = self.client.get("/test_company/forgot_password")
-        assert response.status_code == 404
-
-
-    @patch("iatoolkit.views.forgot_password_view.render_template")
-    def test_post_when_invalid_company(self, mock_render):
-        self.profile_service.get_company_by_short_name.return_value = None
-        response = self.client.post("/test_company/forgot_password",
-                                    data={"email": "nonexistent@email.com"},
-                                    content_type="application/x-www-form-urlencoded")
-
-        assert response.status_code == 404
-
-    @patch("iatoolkit.views.forgot_password_view.render_template")
-    def test_get_forgot_password_page(self, mock_render_template):
-        mock_render_template.return_value = "<html><body><h1>Forgot Password</h1></body></html>"
-        response = self.client.get("/test_company/forgot_password")
-
-        mock_render_template.assert_called_once_with(
-            "forgot_password.html",
-            company=self.test_company,
-            company_short_name='test_company',
-        )
-        assert response.status_code == 200
-
-    @patch("iatoolkit.views.forgot_password_view.url_for")
-    @patch("iatoolkit.views.forgot_password_view.render_template")
-    @patch("iatoolkit.views.forgot_password_view.URLSafeTimedSerializer")
-    def test_post_with_error(self,
-                             mock_serializer,
-                             mock_render_template,
-                             mock_url_for):
-        mock_serializer.return_value.loads.return_value = "nonexistent@email.com"
-        mock_render_template.return_value = "<html><body><h1>Signup Page</h1></body></html>"
-        mock_url_for.return_value = 'http://verification'
-        self.profile_service.forgot_password.return_value = {'error': 'invalid email'}
-
-        response = self.client.post("/test_company/forgot_password",
-                        data={"email": "nonexistent@email.com"},
-                        content_type="application/x-www-form-urlencoded")
-
-        assert response.status_code == 400
-        mock_render_template.assert_called_once_with(
-            "forgot_password.html",
-            company=self.test_company,
-            company_short_name='test_company',
-            form_data={"email": "nonexistent@email.com"},
-            alert_message='invalid email'
-        )
-
-    @patch("iatoolkit.views.forgot_password_view.url_for")
-    @patch("iatoolkit.views.forgot_password_view.render_template")
-    @patch("iatoolkit.views.forgot_password_view.URLSafeTimedSerializer")
-    def test_post_ok(self,
-                             mock_serializer,
-                             mock_render_template,
-                             mock_url_for):
-        mock_serializer.return_value.loads.return_value = "nonexistent@email.com"
-        mock_render_template.return_value = "<html><body><h1>Signup Page</h1></body></html>"
-        mock_url_for.return_value = 'http://verification'
-        self.profile_service.forgot_password.return_value = {"message": "link sent"}
-
-        response = self.client.post("/test_company/forgot_password",
-                                    data={"email": "nonexistent@email.com"},
-                                    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_icon='success',
-            alert_message="Hemos enviado un enlace a tu correo para restablecer la contraseña."
-        )
-
-    @patch("iatoolkit.views.forgot_password_view.render_template")
-    @patch("iatoolkit.views.forgot_password_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/forgot_password",
-                                    data={"email": "nonexistent@email.com"},
-                                    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