329 lines
15 KiB
Python
329 lines
15 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.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()
|