Plus aucun fichier de secret : la valeur est lue au moment de l'appel, jamais copiee, jamais affichee (--config indique seulement definie/absente). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
200 lignes
8.7 KiB
Python
200 lignes
8.7 KiB
Python
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 lire_json
|
|
from meteo_collecte.stockage import Stockage
|
|
from tests.aide import JETON_FICTIF, FauxReseau, config, fixture, t
|
|
|
|
STATIONS = {"000T0": {"nom": "Lans", "licence": "CC BY"}, "000IL": {"nom": "Autrans", "licence": "CC BY"}}
|
|
|
|
|
|
def instants(debut_min, pas_min, n, retard_min=2):
|
|
"""Fabrique [(dh_utc, recu_utc)] à partir de 10:00 UTC le 16/10."""
|
|
out = []
|
|
for i in range(n):
|
|
m = debut_min + i * pas_min
|
|
out.append(("2026-10-16 %02d:%02d:00" % (10 + m // 60, m % 60),
|
|
"2026-10-16 %02d:%02d:00" % (10 + (m + retard_min) // 60, (m + retard_min) % 60)))
|
|
return out
|
|
|
|
|
|
class TestRythme(unittest.TestCase):
|
|
def test_pas_mesure(self):
|
|
self.assertEqual(ic.mesurer_rythme(instants(0, 10, 6))[0], 600)
|
|
self.assertEqual(ic.mesurer_rythme(instants(0, 15, 6))[0], 900)
|
|
self.assertEqual(ic.mesurer_rythme(instants(0, 20, 5))[0], 1200)
|
|
self.assertEqual(ic.mesurer_rythme([])[0], 600)
|
|
|
|
def test_retard_et_ponctualite(self):
|
|
pas, retard = ic.mesurer_rythme(instants(0, 10, 6, retard_min=14))
|
|
self.assertEqual(retard, 14 * 60)
|
|
self.assertFalse(ic.est_ponctuelle({"retard_s": retard}))
|
|
self.assertTrue(ic.est_ponctuelle({"retard_s": 240}))
|
|
|
|
def test_due(self):
|
|
r = {"derniere": t(11, 50), "pas_s": 600, "retard_s": 120}
|
|
self.assertFalse(ic.est_due(r, t(12, 1)))
|
|
self.assertTrue(ic.est_due(r, t(12, 2)))
|
|
r15 = {"derniere": t(11, 45), "pas_s": 900, "retard_s": 120}
|
|
self.assertFalse(ic.est_due(r15, t(11, 54))) # une station à 15 min n'est pas prise à chaque passage
|
|
self.assertTrue(ic.est_due(r15, t(12, 4)))
|
|
|
|
def test_type_passage(self):
|
|
self.assertEqual(ic.type_passage(t(12, 4)), "principal")
|
|
self.assertEqual(ic.type_passage(t(12, 9)), "rattrapage")
|
|
self.assertEqual(ic.type_passage(t(12, 14)), "principal")
|
|
|
|
def test_planifier_rien_si_aucune_due(self):
|
|
r = {"A": {"derniere": t(12, 0), "pas_s": 600, "retard_s": 60}}
|
|
self.assertEqual(ic.planifier({}, r, t(12, 4)), ("principal", []))
|
|
|
|
def test_rattrapage_cible_seulement_les_ponctuelles_manquees(self):
|
|
r = {"P": {"derniere": t(11, 50), "pas_s": 600, "retard_s": 120}, # ponctuelle, manquée
|
|
"L": {"derniere": t(11, 50), "pas_s": 600, "retard_s": 840}, # toujours en retard
|
|
"X": {"derniere": t(11, 50), "pas_s": 600, "retard_s": 120}} # due mais pas manquée
|
|
genre, cibles = ic.planifier({"manquees": ["P", "L"]}, r, t(12, 9))
|
|
self.assertEqual((genre, cibles), ("rattrapage", ["P"]))
|
|
|
|
def test_pas_deux_principaux_rapproches(self):
|
|
r = {"A": {"derniere": None, "pas_s": 600, "retard_s": None}}
|
|
self.assertEqual(ic.planifier({"dernier_principal_utc": "2026-10-16 12:04:00"}, r, t(12, 8))[1], [])
|
|
|
|
def test_fenetre_courte(self):
|
|
r = {"A": {"derniere": t(11, 50)}}
|
|
self.assertEqual(ic.fenetre({"dernier_jour_utc": "2026-10-16"}, t(12, 4), ["A"], r),
|
|
(t(0, 0).date(), t(0, 0).date()))
|
|
# premier passage après minuit UTC : la veille est ajoutée
|
|
self.assertEqual(ic.fenetre({"dernier_jour_utc": "2026-10-15"}, t(0, 4), ["A"], r)[0].isoformat(),
|
|
"2026-10-15")
|
|
|
|
|
|
class TestReponse(unittest.TestCase):
|
|
def test_lecture_fixture(self):
|
|
m, meta = ic.lire_reponse(fixture("infoclimat_ok.json"), ["000T0", "000IL", "000GS"])
|
|
self.assertEqual(len(m["000T0"]), 2)
|
|
self.assertEqual(m["000T0"][1]["pluie_cumul"], "0.2")
|
|
self.assertEqual(m["000GS"], [])
|
|
self.assertEqual(meta["000T0"]["altitude"], 990)
|
|
|
|
def test_statut_non_ok_meme_en_200(self):
|
|
with self.assertRaises(ic.ErreurInfoclimat):
|
|
ic.lire_reponse(fixture("infoclimat_erreur.json"), ["000T0"])
|
|
with self.assertRaises(ic.ErreurInfoclimat):
|
|
ic.lire_reponse(b"<html>", ["000T0"])
|
|
|
|
def test_url_groupee(self):
|
|
u = ic.construire_url(["000T0", "STATIC0479"], "2026-10-16", "2026-10-16", JETON_FICTIF)
|
|
self.assertEqual(u.count("stations[]="), 2)
|
|
self.assertIn("start=2026-10-16&end=2026-10-16", u)
|
|
self.assertIn("token=" + urllib.parse.quote(JETON_FICTIF, safe=""), u)
|
|
|
|
|
|
class TestPassage(unittest.TestCase):
|
|
def setUp(self):
|
|
self.tmp = tempfile.TemporaryDirectory()
|
|
self.cfg, self.journal = config(self.tmp.name)
|
|
self.st = Stockage(Path(self.tmp.name) / "m.sqlite")
|
|
self.alertes = []
|
|
|
|
def tearDown(self):
|
|
self.st.fermer()
|
|
self.tmp.cleanup()
|
|
|
|
def quota(self):
|
|
return ic.Quota(self.cfg, self.journal, envoyer_alerte=self.alertes.append)
|
|
|
|
def passer(self, quand, reseau):
|
|
return ic.passer(self.cfg, self.st, self.journal, quand, STATIONS, fetch=reseau, quota=self.quota())
|
|
|
|
def test_une_seule_requete_pour_toutes_les_stations(self):
|
|
r = FauxReseau(fixture("infoclimat_ok.json"))
|
|
res = self.passer(t(12, 4), r)
|
|
self.assertEqual(len(r.urls), 1)
|
|
self.assertEqual(res["requetes"], 1)
|
|
self.assertEqual(self.st.compter("infoclimat"), 3)
|
|
self.assertEqual(lire_json(self.cfg.quota_commun, {})["requetes"], 1)
|
|
# 000IL n'a rien de neuf après 11:40 ? Elle a reçu une mesure : pas manquée.
|
|
self.assertEqual(lire_json(self.cfg.base / "var" / "etat_infoclimat.json", {})["manquees"], [])
|
|
|
|
def test_aucun_appel_si_rien_n_est_du(self):
|
|
r = FauxReseau(fixture("infoclimat_ok.json"))
|
|
self.passer(t(12, 4), r)
|
|
r2 = FauxReseau(fixture("infoclimat_ok.json"))
|
|
res = self.passer(t(12, 4).replace(second=30), r2) # même passage : bloqué
|
|
self.assertEqual(r2.urls, [])
|
|
self.assertEqual(res["requetes"], 0)
|
|
|
|
def test_sans_jeton_aucun_appel_ni_quota(self):
|
|
del self.cfg.env["MC_JETON_INFOCLIMAT"]
|
|
r = FauxReseau(fixture("infoclimat_ok.json"))
|
|
res = self.passer(t(12, 4), r)
|
|
self.assertEqual((res["action"], r.urls), ("sans_jeton", []))
|
|
self.assertEqual(lire_json(self.cfg.quota_commun, {}).get("requetes", 0), 0)
|
|
|
|
def test_erreur_pause_15_min_et_jeton_masque(self):
|
|
r = FauxReseau(OSError("échec pour url https://x/?token=%s" % urllib.parse.quote(JETON_FICTIF, safe="")))
|
|
res = self.passer(t(12, 4), r)
|
|
self.assertEqual(res["action"], "erreur")
|
|
journal = (self.cfg.base / "var" / "journal.log").read_text(encoding="utf-8")
|
|
self.assertIn("pause 15 min", journal)
|
|
self.assertNotIn("FICTIF", journal)
|
|
self.assertNotIn("FICTIF", json.dumps(res))
|
|
r2 = FauxReseau(fixture("infoclimat_ok.json"))
|
|
self.assertEqual(self.passer(t(12, 14), r2)["action"], "pause")
|
|
self.assertEqual(r2.urls, [])
|
|
self.assertEqual(self.passer(t(12, 24), r2)["action"], "appel")
|
|
|
|
def test_plafond_site(self):
|
|
self.cfg.plafond_site = 1
|
|
self.passer(t(12, 4), FauxReseau(fixture("infoclimat_ok.json")))
|
|
r2 = FauxReseau(fixture("infoclimat_ok.json"))
|
|
res = self.passer(t(13, 4), r2)
|
|
self.assertEqual(res["action"], "plafond")
|
|
self.assertEqual(r2.urls, [])
|
|
|
|
def test_plafond_commun(self):
|
|
self.cfg.quota_commun.write_text(json.dumps({"date": "2026-10-16", "requetes": 4999}))
|
|
r = FauxReseau(fixture("infoclimat_ok.json"))
|
|
self.assertEqual(self.passer(t(12, 4), r)["action"], "plafond")
|
|
self.assertEqual(r.urls, [])
|
|
|
|
def test_compteur_24h_glissantes(self):
|
|
q = self.quota()
|
|
self.cfg.plafond_site = 3
|
|
for h in (19, 20, 21):
|
|
q.noter(1, t(h, 0, jour=15))
|
|
# nouveau jour de Paris (16/10) mais 3 requêtes dans les 24 h : refus
|
|
self.assertEqual(q.etat(t(12, 0))["site_jour"], 0)
|
|
self.assertFalse(q.peut(1, t(12, 0)))
|
|
self.assertTrue(q.peut(1, t(20, 30)))
|
|
|
|
def test_alerte_80_pour_cent_une_fois_par_jour(self):
|
|
self.cfg.plafond_site = 10
|
|
q = self.quota()
|
|
for i in range(10):
|
|
q.noter(1, t(12, i))
|
|
self.assertEqual(len(self.alertes), 1)
|
|
self.assertIn("8 requêtes", self.alertes[0])
|
|
|
|
def test_envoi_ntfy_desactive_par_defaut(self):
|
|
self.assertFalse(ic.envoyer_ntfy(self.cfg, "test"))
|
|
|
|
def test_compte_par_station(self):
|
|
self.cfg.compte_par_station = True
|
|
res = self.passer(t(12, 4), FauxReseau(fixture("infoclimat_ok.json")))
|
|
self.assertEqual(res["requetes"], 2)
|
|
|
|
def test_lots_de_25(self):
|
|
self.cfg.lot_max = 1
|
|
r = FauxReseau(fixture("infoclimat_ok.json"))
|
|
self.passer(t(12, 4), r)
|
|
self.assertEqual(len(r.urls), 2)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|