Fichiers
meteo-collecte/tests/test_hors_ligne.py
T
Théo GastineletClaude Opus 5.5 d12d75c7b2 Tests hors ligne : reseau coupe, scenarios de plusieurs jours simules
Garde-fou socket dans tests/__init__.py ; 3 jours normaux, plafond site,
panne longue, sans secrets, purge 14 jours, passage a l'heure d'hiver.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 20:09:10 +02:00

169 lignes
7.7 KiB
Python

"""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()