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>
163 lignes
6.8 KiB
Python
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()
|