Files
notebook-mcp/tests/test_notebook_mcp.py
T

379 lines
17 KiB
Python

#!/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.WatchedRotatingFileHandler(
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):
for h in list(server.access_logger.handlers):
h.close()
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))
def test_journal_resiste_renommage_suppression_remplacement(self):
"""Vérifie que le journal résiste au renommage, suppression et remplacement (nouvel inode)."""
# Écriture initiale
server.log_access("test-pilote", "notebook_list", None, "ok", 10)
self.assertTrue(os.path.exists(self.access_log_path))
with open(self.access_log_path, "r", encoding="utf-8") as f:
content1 = f.read()
self.assertIn("identity=test-pilote", content1)
self.assertIn("tool=notebook_list", content1)
# 1. Renommage : le fichier d'origine est déplacé
moved = self.access_log_path + ".verif_renomme"
os.rename(self.access_log_path, moved)
self.assertFalse(os.path.exists(self.access_log_path))
# Écriture suivante -> nouveau fichier créé avec la nouvelle ligne
server.log_access("test-pilote", "notebook_get", "notebook:1", "ok", 15)
self.assertTrue(os.path.exists(self.access_log_path))
with open(self.access_log_path, "r", encoding="utf-8") as f:
content2 = f.read()
self.assertIn("tool=notebook_get", content2)
self.assertNotIn("tool=notebook_list", content2)
# 2. Suppression : le fichier est supprimé
os.remove(self.access_log_path)
self.assertFalse(os.path.exists(self.access_log_path))
# Écriture suivante -> nouveau fichier créé avec la nouvelle ligne
server.log_access("test-pilote", "notebook_ask", "notebook:1", "ok", 20)
self.assertTrue(os.path.exists(self.access_log_path))
with open(self.access_log_path, "r", encoding="utf-8") as f:
content3 = f.read()
self.assertIn("tool=notebook_ask", content3)
# 3. Remplacement : remplacement par un fichier avec un autre inode (os.replace)
replaced = self.access_log_path + ".verif_replace"
with open(replaced, "w", encoding="utf-8") as f:
f.write("2026-10-12T00:00:00Z | identity=autre | ligne_externe\n")
os.replace(replaced, self.access_log_path)
# Écriture suivante -> détection du changement d'inode et réouverture
server.log_access("test-pilote", "source_list", "notebook:1", "ok", 5)
with open(self.access_log_path, "r", encoding="utf-8") as f:
content4 = f.read()
self.assertIn("ligne_externe", content4)
self.assertIn("tool=source_list", content4)
if __name__ == "__main__":
unittest.main()