Files
searxng-mcp/tests/test_searxng_mcp.py
T

285 lines
12 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.WatchedRotatingFileHandler(
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):
for h in list(server.access_logger.handlers):
h.close()
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")
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", 3, 10, "query 1")
self.assertTrue(os.path.exists(self.logs_path))
with open(self.logs_path, "r", encoding="utf-8") as f:
content1 = f.read()
self.assertIn("identity=test-pilote", content1)
self.assertIn("results=3", content1)
# 1. Renommage : le fichier d'origine est déplacé
moved = self.logs_path + ".verif_renomme"
os.rename(self.logs_path, moved)
self.assertFalse(os.path.exists(self.logs_path))
# Écriture suivante -> nouveau fichier créé avec la nouvelle ligne
server.log_access("test-pilote", 5, 15, "query 2")
self.assertTrue(os.path.exists(self.logs_path))
with open(self.logs_path, "r", encoding="utf-8") as f:
content2 = f.read()
self.assertIn("results=5", content2)
self.assertNotIn("results=3", content2)
# 2. Suppression : le fichier est supprimé
os.remove(self.logs_path)
self.assertFalse(os.path.exists(self.logs_path))
# Écriture suivante -> nouveau fichier créé avec la nouvelle ligne
server.log_access("test-pilote", 8, 20, "query 3")
self.assertTrue(os.path.exists(self.logs_path))
with open(self.logs_path, "r", encoding="utf-8") as f:
content3 = f.read()
self.assertIn("results=8", content3)
# 3. Remplacement : remplacement par un fichier avec un autre inode (os.replace)
replaced = self.logs_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.logs_path)
# Écriture suivante -> détection du changement d'inode et réouverture
server.log_access("test-pilote", 12, 25, "query 4")
with open(self.logs_path, "r", encoding="utf-8") as f:
content4 = f.read()
self.assertIn("ligne_externe", content4)
self.assertIn("results=12", content4)
if __name__ == "__main__":
unittest.main()