feat(mcp): passerelle MCP notebook-mcp pour Open Notebook cloisonné par sphère (infra-2026-10-042)

This commit is contained in:
bolbol committed 2026-10-12 03:44:10 +02:00
commit cc20ccef2f
9 files changed
+1110

No files matched your search

+199
View File
@@ -0,0 +1,199 @@
#!/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
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)
if __name__ == "__main__":
unittest.main()