#!/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 mise en valeur du résultat {i} avec lien.", "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 = "
Début " + ("mot " * 150) + "fin
" 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("", snippet) self.assertNotIn("", 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()