235 lines
9.8 KiB
Python
235 lines
9.8 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
"""Tests unitaires du serveur MCP searxng-mcp.
|
|
Module unittest standard, sans réseau (mocks)."""
|
|
|
|
import hashlib
|
|
import json
|
|
import os
|
|
import tempfile
|
|
import time
|
|
import unittest
|
|
from unittest.mock import AsyncMock, MagicMock, patch
|
|
|
|
import server
|
|
|
|
|
|
class TestSearxngMcp(unittest.IsolatedAsyncioTestCase):
|
|
|
|
def setUp(self):
|
|
# Configuration d'un fichier de tokens temporaire
|
|
self.temp_dir = tempfile.TemporaryDirectory()
|
|
self.tokens_path = os.path.join(self.temp_dir.name, "tokens.json")
|
|
self.logs_path = os.path.join(self.temp_dir.name, "access.log")
|
|
|
|
# Test token
|
|
self.test_token = "mon_secret_token_12345"
|
|
self.test_hash = hashlib.sha256(self.test_token.encode("utf-8")).hexdigest()
|
|
with open(self.tokens_path, "w", encoding="utf-8") as f:
|
|
json.dump({self.test_hash: "test-pilote"}, f)
|
|
|
|
server.TOKENS_FILE = self.tokens_path
|
|
server.LOGS_DIR = self.temp_dir.name
|
|
server.ACCESS_LOG_PATH = self.logs_path
|
|
server._token_cache = {"mtime": None, "tokens": {}}
|
|
server._rate_limits.clear()
|
|
|
|
# Reconfigurer le handler access_logger vers le fichier temporaire
|
|
server.access_logger.handlers.clear()
|
|
rfh = server.logging.handlers.RotatingFileHandler(
|
|
self.logs_path, maxBytes=5 * 1024 * 1024, backupCount=3, encoding="utf-8"
|
|
)
|
|
rfh.setFormatter(server.logging.Formatter("%(message)s"))
|
|
server.access_logger.addHandler(rfh)
|
|
|
|
server.CURRENT_IDENTITY.set("test-pilote")
|
|
|
|
def tearDown(self):
|
|
server.access_logger.handlers.clear()
|
|
self.temp_dir.cleanup()
|
|
|
|
def _sample_searxng_response(self, count=10):
|
|
results = []
|
|
for i in range(count):
|
|
results.append({
|
|
"title": f"Titre {i}",
|
|
"url": f"https://example.com/{i}",
|
|
"content": f"Description <b>mise en valeur</b> du résultat {i} avec <a href='#'>lien</a>.",
|
|
"engines": ["bing", "mojeek"],
|
|
"publishedDate": "2026-10-11T12:00:00Z"
|
|
})
|
|
return {
|
|
"query": "test query",
|
|
"results": results,
|
|
"unresponsive_engines": [["brave", "rate limited"]]
|
|
}
|
|
|
|
async def test_max_results_clamping(self):
|
|
"""1. Bornes de max_results : < 1 -> 1, > 15 -> 15, défaut 8."""
|
|
mock_data = self._sample_searxng_response(20)
|
|
with patch("httpx.AsyncClient.get") as mock_get:
|
|
mock_resp = MagicMock()
|
|
mock_resp.json.return_value = mock_data
|
|
mock_resp.raise_for_status.return_value = None
|
|
mock_get.return_value = mock_resp
|
|
|
|
# max_results < 1
|
|
res_min = await server.web_search(query="test", max_results=-5)
|
|
self.assertEqual(len(res_min["results"]), 1)
|
|
|
|
# max_results > 15
|
|
res_max = await server.web_search(query="test", max_results=99)
|
|
self.assertEqual(len(res_max["results"]), 15)
|
|
|
|
# max_results par défaut
|
|
res_default = await server.web_search(query="test")
|
|
self.assertEqual(len(res_default["results"]), 8)
|
|
|
|
async def test_output_contract(self):
|
|
"""2. Contrat de sortie : structure, clés, types de premier et second niveau."""
|
|
mock_data = self._sample_searxng_response(3)
|
|
with patch("httpx.AsyncClient.get") as mock_get:
|
|
mock_resp = MagicMock()
|
|
mock_resp.json.return_value = mock_data
|
|
mock_resp.raise_for_status.return_value = None
|
|
mock_get.return_value = mock_resp
|
|
|
|
res = await server.web_search(query="paris capitale", max_results=2)
|
|
self.assertIn("query", res)
|
|
self.assertIn("results", res)
|
|
self.assertIn("unresponsive_engines", res)
|
|
self.assertIn("elapsed_ms", res)
|
|
self.assertIsInstance(res["elapsed_ms"], int)
|
|
self.assertEqual(len(res["results"]), 2)
|
|
self.assertEqual(res["unresponsive_engines"], ["brave"])
|
|
|
|
for item in res["results"]:
|
|
for key in ("title", "url", "snippet", "engines", "published"):
|
|
self.assertIn(key, item)
|
|
self.assertIsInstance(item["engines"], list)
|
|
|
|
async def test_snippet_truncation_and_no_html(self):
|
|
"""3. Snippet sans balises HTML et tronqué à 300 caractères."""
|
|
long_html = "<p>Début " + ("mot " * 150) + "<b>fin</b></p>"
|
|
mock_data = {
|
|
"query": "html test",
|
|
"results": [{
|
|
"title": "Page avec HTML",
|
|
"url": "https://example.com/html",
|
|
"content": long_html,
|
|
"engines": ["duckduckgo"],
|
|
"publishedDate": ""
|
|
}],
|
|
"unresponsive_engines": []
|
|
}
|
|
with patch("httpx.AsyncClient.get") as mock_get:
|
|
mock_resp = MagicMock()
|
|
mock_resp.json.return_value = mock_data
|
|
mock_resp.raise_for_status.return_value = None
|
|
mock_get.return_value = mock_resp
|
|
|
|
res = await server.web_search(query="html test", max_results=1)
|
|
snippet = res["results"][0]["snippet"]
|
|
self.assertLessEqual(len(snippet), 300)
|
|
self.assertNotRegex(snippet, r"<[a-zA-Z/][^>]*>")
|
|
self.assertNotIn("<b>", snippet)
|
|
self.assertNotIn("<p>", snippet)
|
|
|
|
async def test_empty_query_rejected(self):
|
|
"""4. Requête vide ou invalide refusée avec une exception explicite."""
|
|
with self.assertRaises(ValueError) as ctx:
|
|
await server.web_search(query="")
|
|
self.assertIn("vide", str(ctx.exception).lower())
|
|
|
|
with self.assertRaises(ValueError) as ctx_space:
|
|
await server.web_search(query=" ")
|
|
self.assertIn("vide", str(ctx_space.exception).lower())
|
|
|
|
async def test_query_too_long_rejected(self):
|
|
"""5. Requête dépassant 300 caractères refusée."""
|
|
long_query = "x" * 301
|
|
with self.assertRaises(ValueError) as ctx:
|
|
await server.web_search(query=long_query)
|
|
self.assertIn("300", str(ctx.exception))
|
|
|
|
def test_auth_validation(self):
|
|
"""6. Authentification : 401 si jeton absent ou invalide, acceptation si hash présent."""
|
|
self.assertIsNone(server.get_identity(None))
|
|
self.assertIsNone(server.get_identity(""))
|
|
self.assertIsNone(server.get_identity("faux_jeton_inconnu"))
|
|
self.assertEqual(server.get_identity(self.test_token), "test-pilote")
|
|
|
|
async def test_rate_limit(self):
|
|
"""7. Limite de débit : refus immédiat au-delà de RATE_LIMIT_PER_MIN sans interroger SearXNG."""
|
|
mock_data = self._sample_searxng_response(1)
|
|
server.RATE_LIMIT_PER_MIN = 3
|
|
with patch("httpx.AsyncClient.get") as mock_get:
|
|
mock_resp = MagicMock()
|
|
mock_resp.json.return_value = mock_data
|
|
mock_resp.raise_for_status.return_value = None
|
|
mock_get.return_value = mock_resp
|
|
|
|
# 3 appels autorisés
|
|
await server.web_search(query="req1")
|
|
await server.web_search(query="req2")
|
|
await server.web_search(query="req3")
|
|
self.assertEqual(mock_get.call_count, 3)
|
|
|
|
# 4ème appel refusé
|
|
with self.assertRaises(ValueError) as ctx:
|
|
await server.web_search(query="req4")
|
|
self.assertIn("débit", str(ctx.exception).lower())
|
|
# SearXNG n'a pas été appelé pour le 4ème
|
|
self.assertEqual(mock_get.call_count, 3)
|
|
|
|
async def test_searxng_unavailable(self):
|
|
"""8. SearXNG indisponible : erreur propre et rapide."""
|
|
with patch("httpx.AsyncClient.get", side_effect=Exception("Connection refused")):
|
|
with self.assertRaises(RuntimeError) as ctx:
|
|
await server.web_search(query="test indisponible")
|
|
self.assertIn("indisponible", str(ctx.exception).lower())
|
|
|
|
async def test_token_not_in_access_log(self):
|
|
"""9. Absence de fuite du jeton dans access.log et présence de l'identité."""
|
|
mock_data = self._sample_searxng_response(2)
|
|
with patch("httpx.AsyncClient.get") as mock_get:
|
|
mock_resp = MagicMock()
|
|
mock_resp.json.return_value = mock_data
|
|
mock_resp.raise_for_status.return_value = None
|
|
mock_get.return_value = mock_resp
|
|
|
|
await server.web_search(query="Recherche sécurisée", max_results=2)
|
|
|
|
with open(self.logs_path, "r", encoding="utf-8") as f:
|
|
log_content = f.read()
|
|
|
|
self.assertIn("test-pilote", log_content)
|
|
self.assertIn("results=2", log_content)
|
|
self.assertNotIn(self.test_token, log_content)
|
|
self.assertNotIn(self.test_hash, log_content)
|
|
|
|
async def test_categories_and_time_range(self):
|
|
"""10. Validation des catégories et de time_range."""
|
|
mock_data = self._sample_searxng_response(1)
|
|
with patch("httpx.AsyncClient.get") as mock_get:
|
|
mock_resp = MagicMock()
|
|
mock_resp.json.return_value = mock_data
|
|
mock_resp.raise_for_status.return_value = None
|
|
mock_get.return_value = mock_resp
|
|
|
|
# Catégorie invalide -> ramenée à general
|
|
await server.web_search(query="test", categories="inconnue", time_range="inconnu")
|
|
args, kwargs = mock_get.call_args
|
|
self.assertEqual(kwargs["params"]["categories"], "general")
|
|
self.assertNotIn("time_range", kwargs["params"])
|
|
|
|
# Catégorie valide et time_range valide
|
|
await server.web_search(query="test", categories="it", time_range="week")
|
|
args, kwargs = mock_get.call_args
|
|
self.assertEqual(kwargs["params"]["categories"], "it")
|
|
self.assertEqual(kwargs["params"]["time_range"], "week")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|