Fichiers
meteo-collecte/tests/test_frequence.py
T
Théo GastineletClaude Sonnet 5.5 4dab8c7388 Infoclimat : frequence_min par station (dashboard meteo-lan)
Une station qui porte frequence_min (5 a 1440, export meteo-lan) n'est due
qu'apres max(frequence_min, rythme mesure) + delai de publication depuis sa
derniere mesure. Sans le champ : comportement inchange. Valeur invalide
(non entier, bool, hors 5-1440) : ignoree, une ligne de journal.

Tests hors ligne : validation, regle de due, simulation 24 h (vraie passer,
faux serveur) : 144 requetes sans champ ou a 10 min, 48 a 30 min, 24 a 60 min.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-18 21:10:26 +02:00

163 lignes
6.8 KiB
Python

"""frequence_min (réglée dans le dashboard meteo-lan) : due après max(frequence_min, rythme mesuré). Hors ligne."""
import datetime as dt
import json
import tempfile
import unittest
import urllib.parse
from pathlib import Path
from meteo_collecte import infoclimat as ic
from meteo_collecte.commun import UTC
from meteo_collecte.stockage import Stockage
from tests.aide import config, t
def r(derniere, pas_s=600, **kw):
return dict({"derniere": derniere, "pas_s": pas_s, "retard_s": 120}, **kw)
class TestValidation(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.cfg, self.journal = config(self.tmp.name)
def tearDown(self):
self.tmp.cleanup()
def lire_journal(self):
return self.journal.fichier.read_text(encoding="utf-8") if self.journal.fichier.exists() else ""
def test_valeurs_valides(self):
f = ic.frequences_configurees({"a": {"frequence_min": 5}, "b": {"frequence_min": 60},
"c": {"frequence_min": 1440}}, self.journal, t(12, 4))
self.assertEqual(f, {"a": 300, "b": 3600, "c": 86400})
self.assertEqual(self.lire_journal(), "")
def test_champ_absent_ignore_sans_journal(self):
self.assertEqual(ic.frequences_configurees({"a": {"nom": "x"}}, self.journal, t(12, 4)), {})
self.assertEqual(self.lire_journal(), "")
def test_valeurs_invalides_ignorees_avec_une_ligne_chacune(self):
mauvaises = [4, 1441, 0, -10, 30.5, "30", None, True, [30]]
stations = {"s%d" % i: {"frequence_min": v} for i, v in enumerate(mauvaises)}
self.assertEqual(ic.frequences_configurees(stations, self.journal, t(12, 4)), {})
lignes = self.lire_journal().strip().splitlines()
self.assertEqual(len(lignes), len(mauvaises))
self.assertTrue(all("frequence_min invalide" in x for x in lignes))
def test_entree_non_dictionnaire_ne_plante_pas(self):
self.assertEqual(ic.frequences_configurees({"a": "texte", "b": None}, self.journal, t(12, 4)), {})
class TestDue(unittest.TestCase):
def test_sans_champ_comportement_inchange(self):
d = t(12, 0)
self.assertFalse(ic.est_due(r(d), t(12, 11)))
self.assertTrue(ic.est_due(r(d), t(12, 12)))
def test_frequence_plus_lente_que_la_station(self):
d = t(12, 0)
st = r(d, 600, frequence_s=1800)
self.assertFalse(ic.est_due(st, t(12, 31)))
self.assertTrue(ic.est_due(st, t(12, 32))) # 30 min + 2 min de publication
def test_jamais_plus_souvent_que_la_station(self):
d = t(12, 0)
st = r(d, 1800, frequence_s=300) # station lente (30 min), réglage 5 min
self.assertEqual(ic.pas_effectif_s(st), 1800)
self.assertFalse(ic.est_due(st, t(12, 20)))
self.assertTrue(ic.est_due(st, t(12, 32)))
def test_jamais_vue_toujours_due(self):
self.assertTrue(ic.est_due(r(None, 600, frequence_s=3600), t(12, 4)))
def test_planifier_exclut_la_station_non_due(self):
rs = {"lente": r(t(12, 0), 600, frequence_s=3600), "libre": r(t(12, 0), 600)}
genre, cibles = ic.planifier({}, rs, t(12, 14))
self.assertEqual((genre, cibles), ("principal", ["libre"]))
class FauxServeur:
"""Stations qui publient toutes les `pas` minutes avec 2 min de retard ; compte les requêtes et stations."""
def __init__(self, pas=10):
self.pas, self.maintenant = pas, None
self.requetes, self.stations_demandees = 0, 0
def __call__(self, url):
q = urllib.parse.parse_qs(urllib.parse.urlparse(url).query)
ids = q["stations[]"]
self.requetes += 1
self.stations_demandees += len(ids)
debut = dt.datetime.strptime(q["start"][0], "%Y-%m-%d").replace(tzinfo=UTC)
limite = self.maintenant - dt.timedelta(minutes=2)
horaire, m = {}, debut
while m <= limite:
if m.minute % self.pas == 0:
for s in ids:
horaire.setdefault(s, []).append({"dh_utc": m.strftime("%Y-%m-%d %H:%M:%S"), "temperature": "7.0"})
m += dt.timedelta(minutes=1)
return json.dumps({"status": "OK", "errors": [], "stations": [], "hourly": horaire}).encode()
def simuler_24h(frequence_min, nb_stations=3, pas_station=10, debut=None):
"""Tick toutes les 5 min (hh:x4 et hh:x9) pendant 24 h, avec la vraie `passer`. -> (requêtes, stations demandées)."""
debut = debut or dt.datetime(2026, 10, 16, 0, 4, tzinfo=UTC)
stations = {}
for i in range(nb_stations):
stations["S%d" % i] = {"nom": "s", "licence": "CC BY"}
if frequence_min is not None:
stations["S%d" % i]["frequence_min"] = frequence_min
with tempfile.TemporaryDirectory() as tmp:
cfg, journal = config(tmp)
st = Stockage(Path(tmp) / "m.sqlite")
srv = FauxServeur(pas_station)
try:
for k in range(24 * 12):
srv.maintenant = debut + dt.timedelta(minutes=5 * k)
ic.passer(cfg, st, journal, srv.maintenant, stations, fetch=srv)
finally:
st.fermer()
return srv.requetes, srv.stations_demandees
class TestSimulation24h(unittest.TestCase):
resultats = {}
@classmethod
def setUpClass(cls):
for f in (None, 10, 30, 60):
cls.resultats[f] = simuler_24h(f)
base = cls.resultats[None][0]
print("\n[simulation 24 h, 3 stations qui publient toutes les 10 min, 288 ticks de 5 min]")
for f, (req, sta) in cls.resultats.items():
print(" frequence_min=%-5s -> %3d requêtes, %3d demandes de station%s" % (
f if f else "absent", req, sta,
"" if f is None else " (gain %d requêtes, %.0f %%)" % (base - req, 100 * (base - req) / base)))
def test_sans_champ_identique_au_comportement_actuel(self):
self.assertEqual(self.resultats[None][0], 144) # même valeur que test_ordonnanceur (144/24 h)
def test_10_min_egale_la_station(self):
self.assertEqual(self.resultats[10], self.resultats[None])
def test_30_et_60_min_reduisent_les_requetes(self):
self.assertLess(self.resultats[30][0], self.resultats[10][0])
self.assertLess(self.resultats[60][0], self.resultats[30][0])
def test_ordre_de_grandeur(self):
# ~1 requête par période + le premier passage ; marge pour le démarrage et les dérives de 5 min
self.assertTrue(24 * 60 // 30 <= self.resultats[30][0] <= 24 * 60 // 30 + 3)
self.assertTrue(24 * 60 // 60 <= self.resultats[60][0] <= 24 * 60 // 60 + 3)
def test_frequence_5_ne_depasse_pas_le_rythme_de_la_station(self):
self.assertEqual(simuler_24h(5)[0], self.resultats[None][0])
def test_station_lente_30_min_avec_reglage_10(self):
lent = simuler_24h(10, pas_station=30)[0]
self.assertEqual(lent, simuler_24h(None, pas_station=30)[0])
if __name__ == "__main__":
unittest.main()