diff --git a/tests/__init__.py b/tests/__init__.py index e69de29..a8a37f9 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -0,0 +1,47 @@ +"""Tests hors ligne : dès l'import du paquet de tests, toute sortie réseau est coupée. + +Résolution DNS et connexions TCP/UDP lèvent une erreur, sauf vers la boucle locale. Ainsi aucun test ne peut +joindre Infoclimat ou ROMMA, même par erreur (pytest comme `python -m unittest`). +""" +import socket + + +class ReseauInterdit(RuntimeError): + pass + + +_LOCAUX = ("127.0.0.1", "::1", "localhost") + + +def _hote(adresse): + return adresse[0] if isinstance(adresse, tuple) and adresse else adresse + + +def _verifier(hote): + if hote not in _LOCAUX: + raise ReseauInterdit("accès réseau interdit pendant les tests : %r" % (hote,)) + + +_connect_orig = socket.socket.connect +_connect_ex_orig = socket.socket.connect_ex +_getaddrinfo_orig = socket.getaddrinfo + + +def _connect(self, adresse): + _verifier(_hote(adresse)) + return _connect_orig(self, adresse) + + +def _connect_ex(self, adresse): + _verifier(_hote(adresse)) + return _connect_ex_orig(self, adresse) + + +def _getaddrinfo(host, *a, **kw): + _verifier(host) + return _getaddrinfo_orig(host, *a, **kw) + + +socket.socket.connect = _connect +socket.socket.connect_ex = _connect_ex +socket.getaddrinfo = _getaddrinfo diff --git a/tests/test_hors_ligne.py b/tests/test_hors_ligne.py new file mode 100644 index 0000000..7481ed4 --- /dev/null +++ b/tests/test_hors_ligne.py @@ -0,0 +1,168 @@ +"""Scénarios complets hors ligne : plusieurs jours de ticks avec des serveurs simulés. + +Aucun accès réseau (voir tests/__init__.py), aucun vrai secret, horloge simulée. +""" +import datetime as dt +import json +import tempfile +import unittest +from pathlib import Path + +from meteo_collecte import infoclimat, ordonnanceur, romma +from meteo_collecte.commun import fmt_utc, lire_json, vers_paris +from meteo_collecte.stockage import Stockage +from tests import ReseauInterdit +from tests.aide import CLE_FICTIVE, JETON_FICTIF, config, t + +STATIONS_IC = {"000T0": {"nom": "Lans"}, "000IL": {"nom": "Autrans"}, "000HT": {"nom": "Engins"}} + + +class ServeurInfoclimat: + """Publie une mesure toutes les `pas` minutes, en ligne 2 min après l'instant de mesure.""" + + def __init__(self, pas=10, panne=False): + self.pas, self.panne, self.n, self.maintenant = pas, panne, 0, None + + def __call__(self, url): + self.n += 1 + if self.panne: + raise OSError("HTTP 503 pour %s" % url) # l'URL contient le jeton : il doit être masqué + fin = self.maintenant - dt.timedelta(minutes=2) + dh = fin.replace(minute=fin.minute - fin.minute % self.pas, second=0, microsecond=0) + lignes = [{"dh_utc": fmt_utc(dh - dt.timedelta(minutes=self.pas * i)), "temperature": "5.0", + "pression": "1015"} for i in range(3)] + ids = [s for s in STATIONS_IC if "stations[]=" + s in url] + return json.dumps({"status": "OK", "hourly": {s: lignes for s in ids}}).encode() + + +class ServeurRomma: + """Renvoie l'état « live » de deux stations, heure locale de Paris, comme l'API réelle.""" + + def __init__(self): + self.n, self.maintenant = 0, None + + def __call__(self, url): + self.n += 1 + local = vers_paris(self.maintenant - dt.timedelta(minutes=3)) + local = local.replace(minute=local.minute - local.minute % 10) + return json.dumps([ + {"id_station": n, "station": "Fictive %d" % n, "is_valide": 1, "latitude": 45.1, "longitude": 5.6, + "date": local.strftime("%d/%m/%y"), "heure": local.strftime("%H:%M"), "temperature": "7,5", + "humidite": "NULL", "vent_direction": "SSO", "pluie_jour": "0.2"} for n in (9001, 9002)]).encode() + + +class TestHorsLigne(unittest.TestCase): + def setUp(self): + self.tmp = tempfile.TemporaryDirectory() + self.dossier = Path(self.tmp.name) + self.cfg, _ = config(self.tmp.name) + st = self.dossier / "stations.json" + st.write_text(json.dumps({"infoclimat": STATIONS_IC}), encoding="utf-8") + self.cfg.stations = st + + def tearDown(self): + self.tmp.cleanup() + + def simuler(self, ic, ro, debut, ticks): + for i in range(ticks): + ic.maintenant = ro.maintenant = debut + dt.timedelta(minutes=5 * i) + ordonnanceur.tick(self.cfg, ic.maintenant, ic, ro) + + def textes_ecrits(self): + for p in self.dossier.rglob("*"): + if p.is_file() and p.suffix != ".sqlite": + yield p, p.read_text(encoding="utf-8", errors="replace") + + # -- garde-fou réseau -------------------------------------------------------------------------- + + def test_reseau_reellement_coupe(self): + with self.assertRaises(ReseauInterdit): + infoclimat.telecharger("https://www.infoclimat.fr/opendata/?version=2") + with self.assertRaises(ReseauInterdit): + romma.telecharger("https://www.romma.fr/api_export.php/") + + # -- fonctionnement normal sur 3 jours ---------------------------------------------------------- + + def test_trois_jours_normaux(self): + ic, ro = ServeurInfoclimat(), ServeurRomma() + self.simuler(ic, ro, t(0, 4), 3 * 288) + par_jour_ic, par_jour_ro = ic.n / 3, ro.n / 3 + print("\n[3 jours] Infoclimat %.0f req/jour, ROMMA %.0f req/jour" % (par_jour_ic, par_jour_ro)) + self.assertLessEqual(par_jour_ic, 150) # bien sous le plafond de 1000 + self.assertLessEqual(par_jour_ro, 144) # au plus toutes les 10 min + self.assertGreaterEqual(par_jour_ro, 140) + q = lire_json(self.cfg.base / "var" / "quota_site.json", {}) + self.assertLessEqual(len(q["horodatages"]), 1000) + idx = lire_json(self.cfg.public / "data" / "stations.json", {}) + self.assertEqual(len(idx["stations"]), 5) + for s in idx["stations"]: + self.assertIsNotNone(s["derniere"], s["id"]) + self.assertLessEqual(s["age_min"], 20, s["id"]) + fiche = lire_json(self.cfg.public / "data" / "station" / (s["id"] + ".json"), {}) + self.assertTrue(fiche["releves"]) + for p, texte in self.textes_ecrits(): + self.assertNotIn("FICTI", texte, p) # ni jeton ni clé, nulle part sur disque + self.assertEqual(list(self.dossier.rglob("*.tmp-*")), []) # aucun fichier à moitié écrit + + def test_station_horaire_peu_de_requetes(self): + ic, ro = ServeurInfoclimat(pas=60), ServeurRomma() + self.simuler(ic, ro, t(0, 4), 2 * 288) + print("\n[pas 60 min] Infoclimat %.0f req/jour" % (ic.n / 2)) + self.assertLessEqual(ic.n / 2, 60) + + # -- garde-fous --------------------------------------------------------------------------------- + + def test_plafond_site_jamais_depasse(self): + self.cfg.plafond_site = 40 + ic, ro = ServeurInfoclimat(), ServeurRomma() + self.simuler(ic, ro, t(0, 4), 288) + self.assertEqual(ic.n, 40) + self.assertIn("plafond", (self.cfg.base / "var" / "collecte.log").read_text(encoding="utf-8")) + + def test_panne_longue_freinee_par_la_pause(self): + ic, ro = ServeurInfoclimat(panne=True), ServeurRomma() + self.simuler(ic, ro, t(0, 4), 288) + print("\n[panne 24 h] Infoclimat %d requêtes" % ic.n) + self.assertLessEqual(ic.n, 72) # une tentative toutes les 20 min au plus + self.assertGreaterEqual(ro.n, 140) # l'autre source continue + journal = (self.cfg.base / "var" / "collecte.log").read_text(encoding="utf-8") + self.assertIn("pause 15 min", journal) + self.assertNotIn(JETON_FICTIF, journal) + etat = lire_json(self.cfg.public / "data" / "etat.json", {}) + self.assertIn("infoclimat", etat["sources"]) + + def test_sans_secrets_aucun_appel(self): + self.cfg.env = {} + ic, ro = ServeurInfoclimat(), ServeurRomma() + self.simuler(ic, ro, t(0, 4), 24) + self.assertEqual((ic.n, ro.n), (0, 0)) + self.assertTrue((self.cfg.public / "data" / "etat.json").exists()) + + def test_purge_quatorze_jours(self): + ic, ro = ServeurInfoclimat(), ServeurRomma() + self.simuler(ic, ro, t(0, 4, jour=1), 12) + self.simuler(ic, ro, t(12, 4, jour=16), 3) + s = Stockage(self.cfg.base / "var" / "mesures.sqlite") + try: + plus_ancienne = s.db.execute("SELECT MIN(dh_utc) FROM mesures").fetchone()[0] + finally: + s.fermer() + self.assertGreaterEqual(plus_ancienne, "2026-10-02") + + def test_passage_a_l_heure_d_hiver(self): + """Nuit du 24 au 25/10/2026 : ROMMA donne l'heure locale, l'heure 2:xx existe deux fois.""" + ic, ro = ServeurInfoclimat(), ServeurRomma() + self.simuler(ic, ro, dt.datetime(2026, 10, 24, 22, 4, tzinfo=t(0, 0).tzinfo), 72) + s = Stockage(self.cfg.base / "var" / "mesures.sqlite") + try: + dhs = [r[0] for r in s.db.execute( + "SELECT dh_utc FROM mesures WHERE source='romma' AND station_id='9001' ORDER BY dh_utc")] + finally: + s.fermer() + self.assertEqual(len(dhs), len(set(dhs))) + self.assertGreaterEqual(len(dhs), 34) # ~36 relevés sur 6 h malgré l'heure doublée + self.assertNotIn(CLE_FICTIVE, "".join(dhs)) + + +if __name__ == "__main__": + unittest.main()