#!/usr/bin/env python3 # -*- coding: utf-8 -*- """Tests unitaires du serveur MCP notebook-mcp. Module unittest standard testant autorisations, cloisonnement, filtrage a posteriori, limite de débit et journalisation sans fuite.""" import hashlib import json import os import tempfile import time import unittest import httpx from unittest.mock import AsyncMock, patch import server class TestNotebookMcp(unittest.IsolatedAsyncioTestCase): def setUp(self): self.temp_dir = tempfile.TemporaryDirectory() self.state_dir = os.path.join(self.temp_dir.name, "state") self.tokens_path = os.path.join(self.temp_dir.name, "tokens.json") self.logs_dir = os.path.join(self.temp_dir.name, "logs") os.makedirs(self.logs_dir, exist_ok=True) os.makedirs(self.state_dir, exist_ok=True) self.access_log_path = os.path.join(self.logs_dir, "access.log") self.pw_path = os.path.join(self.temp_dir.name, "pw") with open(self.pw_path, "w", encoding="utf-8") as f: f.write("test_super_secret_password_1234") # Test tokens self.token_a = "token_a_12345678901234567890123456789012345678901234" self.token_b = "token_b_12345678901234567890123456789012345678901234" self.hash_a = hashlib.sha256(self.token_a.encode("utf-8")).hexdigest() self.hash_b = hashlib.sha256(self.token_b.encode("utf-8")).hexdigest() with open(self.tokens_path, "w", encoding="utf-8") as f: json.dump({ self.hash_a: "test-pilote", self.hash_b: "test-pilote-b", }, f) server.STATE_DIR = self.state_dir server.REGISTRY_DB_PATH = os.path.join(self.state_dir, "registry.db") server.TOKENS_FILE = self.tokens_path server.LOGS_DIR = self.logs_dir server.ACCESS_LOG_PATH = self.access_log_path server.OPEN_NOTEBOOK_PASSWORD_FILE = self.pw_path server._token_cache = {"mtime": None, "tokens": {}} server._total_calls.clear() server._ask_calls.clear() # Reconfigure logger server.access_logger.handlers.clear() rfh = server.logging.handlers.RotatingFileHandler( self.access_log_path, maxBytes=5 * 1024 * 1024, backupCount=3, encoding="utf-8" ) rfh.setFormatter(server.logging.Formatter("%(message)s")) server.access_logger.addHandler(rfh) server.init_db() def tearDown(self): server.access_logger.handlers.clear() self.temp_dir.cleanup() def test_01_autorisations_table_et_spheres(self): """Vérifie la table des agents et la validation des sphères autorisées.""" # 1. Sphères valides for s in ("tt", "nyora", "perso", "infra", "test-a", "test-b"): self.assertIn(s, server.VALID_SPHERES) # 2. Correspondance agents self.assertEqual(server.AGENTS["hermes-tt"], ["tt"]) self.assertEqual(server.AGENTS["agno-tt"], ["tt"]) self.assertEqual(server.AGENTS["hermes-nyora"], ["infra", "nyora"]) self.assertEqual(server.AGENTS["hermes-perso"], ["perso"]) self.assertEqual(server.AGENTS["openclaw-perso"], ["infra", "perso"]) self.assertEqual(server.AGENTS["hermes-nabil"], ["infra", "nyora", "perso"]) self.assertEqual(server.AGENTS["test-pilote"], ["test-a"]) self.assertEqual(server.AGENTS["test-pilote-b"], ["test-b"]) # 3. Lookup d'identité self.assertEqual(server.get_identity(self.token_a), "test-pilote") self.assertEqual(server.get_identity(self.token_b), "test-pilote-b") self.assertIsNone(server.get_identity("invalid_token")) def test_02_erreur_identique_carnet_inconnu_et_etranger(self): """Un carnet inconnu et un carnet d'une autre sphère doivent donner la même erreur au caractère près.""" # Enregistrer un carnet pour la sphère test-b server.create_notebook_entry("notebook:b123", "test-b", "Carnet B", "desc B", "test-pilote-b") # Pour l'identité test-pilote (sphère test-a seulement) # Carnet inconnu with self.assertRaises(ValueError) as ctx_inconnu: server.check_notebook_auth("notebook:inexistant000", "test-pilote") # Carnet étranger with self.assertRaises(ValueError) as ctx_etranger: server.check_notebook_auth("notebook:b123", "test-pilote") msg_inconnu = str(ctx_inconnu.exception) msg_etranger = str(ctx_etranger.exception) self.assertEqual(msg_inconnu.replace("notebook:inexistant000", "X"), msg_etranger.replace("notebook:b123", "X")) self.assertEqual(msg_inconnu, "Carnet introuvable : notebook:inexistant000") self.assertEqual(msg_etranger, "Carnet introuvable : notebook:b123") @patch("server.on_request") async def test_03_filtrage_a_posteriori_ask(self, mock_on_request): """Vérifie que les sources d'un carnet étranger ou hors registre sont retirées dans notebook_ask.""" server.CURRENT_IDENTITY.set("test-pilote") server.create_notebook_entry("notebook:a1", "test-a", "Carnet A", "", "test-pilote") # Source 1 enregistrée dans carnet A server.create_source_entry("source:valid1", "notebook:a1", "Titre A") # Source 2 enregistrée dans carnet étranger server.create_notebook_entry("notebook:b1", "test-b", "Carnet B", "", "test-pilote-b") server.create_source_entry("source:foreign2", "notebook:b1", "Titre B") # Simuler Open Notebook renvoyant deux sources dont une étrangère async def fake_on_request(method, path, body=None): if path == "/models/defaults": return 200, {"default_chat_model": "test-model"} if path == "/search/ask/simple": return 200, { "answer": "Voici la réponse avec code 4821 et secret étranger 9356.", "sources": [ {"id": "source:valid1", "title": "Titre A"}, {"id": "source:foreign2", "title": "Titre B"}, ] } return 404, {} mock_on_request.side_effect = fake_on_request rep = await server.notebook_ask("notebook:a1", "question test") self.assertEqual(len(rep["sources"]), 1) self.assertEqual(rep["sources"][0]["id"], "source:valid1") # Cas où toutes les sources sont étrangères : doit renvoyer "aucun résultat" async def fake_foreign_only(method, path, body=None): if path == "/models/defaults": return 200, {"default_chat_model": "test-model"} if path == "/search/ask/simple": return 200, { "answer": "Réponse uniquement issue de sources étrangères", "sources": [{"id": "source:foreign2", "title": "Titre B"}] } return 404, {} mock_on_request.side_effect = fake_foreign_only rep_none = await server.notebook_ask("notebook:a1", "question test 2") self.assertEqual(rep_none["answer"], "aucun résultat") self.assertEqual(rep_none["sources"], []) def test_04_limite_de_debit_et_appels_refuses(self): """Vérifie la limite de 10 appels/min sur ask, et que les appels refusés comptent.""" identity = "test-pilote" # 10 appels autorisés for _ in range(10): server.check_and_record_rate_limit(identity, is_ask=True) # Le 11ème doit lever une ValueError avec 'Limite de débit' with self.assertRaises(ValueError) as ctx: server.check_and_record_rate_limit(identity, is_ask=True) self.assertIn("Limite de débit", str(ctx.exception)) # Le 12ème appel échoue également (compte toujours) with self.assertRaises(ValueError) as ctx2: server.check_and_record_rate_limit(identity, is_ask=True) self.assertIn("Limite de débit", str(ctx2.exception)) def test_05_journal_sans_contenu_ni_secret(self): """Vérifie que le journal enregistre les métadonnées et jamais le texte de question/réponse.""" server.log_access("test-pilote", "notebook_ask", "notebook:a1", "ok", 42) with open(self.access_log_path, "r", encoding="utf-8") as f: lines = f.readlines() self.assertEqual(len(lines), 1) line = lines[0].strip() self.assertIn("identity=test-pilote", line) self.assertIn("tool=notebook_ask", line) self.assertIn("notebook_id=notebook:a1", line) self.assertIn("status=ok", line) self.assertIn("duration_ms=42", line) # Vérifier qu'aucun secret ni texte de question ne s'y trouve self.assertNotIn(self.token_a, line) self.assertNotIn("test_super_secret_password_1234", line) @patch("asyncio.sleep") @patch("server.on_request") async def test_message_erreur_non_vide(self, mock_on_request, mock_sleep): """Vérifie que les erreurs (ReadTimeout, ConnectTimeout, 502 après rejeu) produisent un message en français, jamais vide, nommant la panne et indiquant si un nouvel essai a un sens.""" server.CURRENT_IDENTITY.set("test-pilote") server.create_notebook_entry("notebook:a1", "test-a", "Carnet A", "", "test-pilote") # 1. Cas ReadTimeout mock_on_request.side_effect = httpx.ReadTimeout("") with self.assertRaises(Exception) as ctx: await server.notebook_ask("notebook:a1", "question test") msg = str(ctx.exception) self.assertTrue(len(msg) > 0, "Le message ReadTimeout ne doit pas être vide") self.assertIn("délai dépassé", msg.lower()) self.assertTrue("essai" in msg.lower() or "réessayer" in msg.lower()) self.assertNotIn("question test", msg) self.assertNotIn("notebook:a1", msg) # 2. Cas ConnectTimeout mock_on_request.side_effect = httpx.ConnectTimeout("") with self.assertRaises(Exception) as ctx: await server.notebook_ask("notebook:a1", "question test") msg = str(ctx.exception) self.assertTrue(len(msg) > 0, "Le message ConnectTimeout ne doit pas être vide") self.assertIn("délai dépassé", msg.lower()) self.assertTrue("essai" in msg.lower() or "réessayer" in msg.lower()) self.assertNotIn("question test", msg) self.assertNotIn("notebook:a1", msg) # 3. Cas HTTP 502 après rejeu mock_on_request.side_effect = None mock_on_request.return_value = (502, "Bad Gateway") with self.assertRaises(Exception) as ctx: await server.notebook_ask("notebook:a1", "question test") msg = str(ctx.exception) self.assertTrue(len(msg) > 0, "Le message 502 ne doit pas être vide") self.assertIn("502", msg) self.assertIn("open notebook a répondu http 502", msg.lower()) self.assertTrue("essai" in msg.lower() or "réessayer" in msg.lower()) self.assertNotIn("question test", msg) self.assertNotIn("notebook:a1", msg) @patch("asyncio.sleep") @patch("server.on_request") async def test_rejeu_unique_sur_502(self, mock_on_request, mock_sleep): """Vérifie que notebook_ask rejoue une seule fois après 2 secondes sur 502.""" server.CURRENT_IDENTITY.set("test-pilote") server.create_notebook_entry("notebook:a1", "test-a", "Carnet A", "", "test-pilote") # Cas 1 : 1er appel 502, 2nd appel 200 (succès après rejeu) call_count = 0 async def fake_retry(method, path, body=None): nonlocal call_count if path == "/models/defaults": return 200, {"default_chat_model": "test-model"} if path == "/search/ask/simple": call_count += 1 if call_count == 1: return 502, "Bad Gateway" return 200, {"answer": "Réponse après rejeu réussi", "sources": []} return 404, {} mock_on_request.side_effect = fake_retry rep = await server.notebook_ask("notebook:a1", "question test") self.assertEqual(rep["answer"], "Réponse après rejeu réussi") self.assertEqual(call_count, 2, "Doit avoir été appelé exactement 2 fois (1 tentative + 1 rejeu)") mock_sleep.assert_called_with(2.0) # Cas 2 : les deux appels échouent en 502 (rejeu unique, arrêt à 2) call_count_fail = 0 async def fake_both_fail(method, path, body=None): nonlocal call_count_fail if path == "/models/defaults": return 200, {"default_chat_model": "test-model"} if path == "/search/ask/simple": call_count_fail += 1 return 502, "Bad Gateway" return 404, {} mock_on_request.side_effect = fake_both_fail with self.assertRaises(Exception) as ctx: await server.notebook_ask("notebook:a1", "question test") self.assertEqual(call_count_fail, 2, "Doit s'arrêter après un unique rejeu (2 appels au total)") self.assertIn("502", str(ctx.exception)) @patch("asyncio.sleep") @patch("server.on_request") async def test_rejeu_sur_timeout_reussi(self, mock_on_request, mock_sleep): """Vérifie que notebook_ask rejoue après un timeout et réussit si le second appel passe.""" server.CURRENT_IDENTITY.set("test-pilote") server.create_notebook_entry("notebook:a1", "test-a", "Carnet A", "", "test-pilote") call_count = 0 async def fake_timeout_then_ok(method, path, body=None): nonlocal call_count if path == "/models/defaults": return 200, {"default_chat_model": "test-model"} if path == "/search/ask/simple": call_count += 1 if call_count == 1: raise httpx.ReadTimeout("timed out") return 200, {"answer": "Réponse après timeout résolu", "sources": []} return 404, {} mock_on_request.side_effect = fake_timeout_then_ok rep = await server.notebook_ask("notebook:a1", "question test") self.assertEqual(rep["answer"], "Réponse après timeout résolu") self.assertEqual(call_count, 2) mock_sleep.assert_called_with(2.0) @patch("server.on_request") async def test_aucun_rejeu_autres_outils(self, mock_on_request): """Vérifie qu'aucun rejeu n'est effectué pour les autres outils (source_add_text, etc.).""" server.CURRENT_IDENTITY.set("test-pilote") server.create_notebook_entry("notebook:a1", "test-a", "Carnet A", "", "test-pilote") mock_on_request.return_value = (502, "Bad Gateway") with self.assertRaises(Exception) as ctx: await server.source_add_text("notebook:a1", "Titre", "Contenu") self.assertEqual(mock_on_request.call_count, 1) self.assertIn("502", str(ctx.exception)) if __name__ == "__main__": unittest.main()