From fb235a2c857dd62dca149d6cd1653792dfa4ce4e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Th=C3=A9o=20Gastinel?= <264859180+gastinelt@users.noreply.github.com> Date: Mon, 19 Oct 2026 18:13:33 +0200 Subject: [PATCH] WeatherLink : branchement dans le tick et la publication (etat, attribution) + tests avec reponses simulees --- meteo_collecte/ordonnanceur.py | 15 ++- meteo_collecte/publier.py | 12 ++ tests/test_weatherlink.py | 195 +++++++++++++++++++++++++++++++++ 3 files changed, 220 insertions(+), 2 deletions(-) create mode 100644 tests/test_weatherlink.py diff --git a/meteo_collecte/ordonnanceur.py b/meteo_collecte/ordonnanceur.py index 2771cf9..c6ee789 100644 --- a/meteo_collecte/ordonnanceur.py +++ b/meteo_collecte/ordonnanceur.py @@ -13,13 +13,13 @@ ni l'autre source ni la publication. import datetime as dt import sys -from . import infoclimat, publier, romma +from . import infoclimat, publier, romma, weatherlink from .commun import UTC, Config, Journal, Verrou, lire_json from .stockage import Stockage def tick(cfg, maintenant=None, fetch_infoclimat=infoclimat.telecharger, fetch_romma=romma.telecharger, - appels=True): + appels=True, fetch_weatherlink=weatherlink.telecharger, dormir_weatherlink=None): maintenant = maintenant or dt.datetime.now(UTC) var = cfg.base / "var" journal = Journal(var / "collecte.log") @@ -32,6 +32,9 @@ def tick(cfg, maintenant=None, fetch_infoclimat=infoclimat.telecharger, fetch_ro if appels and cfg.romma_actif: resumes["romma"] = _sans_planter(journal, maintenant, "romma", lambda: romma.passer(cfg, stockage, journal, maintenant, fetch_romma)) + if appels and cfg.weatherlink_actif: # opt-in ; quota et état entièrement séparés + resumes["weatherlink"] = _sans_planter(journal, maintenant, "weatherlink", lambda: weatherlink.passer( + cfg, stockage, journal, maintenant, fetch_weatherlink, dormir_weatherlink)) if appels and cfg.infoclimat_actif: stations = lire_json(cfg.stations, {}).get("infoclimat", {}) resumes["infoclimat"] = _sans_planter(journal, maintenant, "infoclimat", lambda: infoclimat.passer( @@ -67,6 +70,14 @@ def main(argv=None): print("%-20s définie (valeur masquée)" % nom) except LookupError: print("%-20s absente" % nom) + if cfg.weatherlink_actif: + for compte, d in lire_json(cfg.weatherlink_comptes, {}).get("comptes", {}).items(): + for nom in (d.get("var_cle"), d.get("var_secret")): + try: + cfg.secret(nom) + print("%-28s définie (valeur masquée) [compte %s]" % (nom, compte)) + except LookupError: + print("%-28s absente [compte %s]" % (nom, compte)) return 0 tick(cfg, appels="--publier" not in argv) return 0 diff --git a/meteo_collecte/publier.py b/meteo_collecte/publier.py index f9bb58c..e02b6e8 100644 --- a/meteo_collecte/publier.py +++ b/meteo_collecte/publier.py @@ -21,6 +21,7 @@ ATTRIBUTIONS = { "infoclimat": "Données Infoclimat", "romma": "Source : ROMMA. ROMMA n'est pas responsable des données erronées ou manquantes ni de leur " "interprétation.", + "weatherlink": "Station Gastinel (Davis), données WeatherLink de la station", "meteofrance": "Source : Météo-France (Licence Ouverte Etalab 2.0)", } @@ -76,6 +77,17 @@ def etat(cfg, maintenant, resumes): "pause_jusqua_utc": iso(p.jusqua()) if p.active(maintenant) else None, "dernier_passage": (resumes.get(src) or {}).get("action"), } + if cfg.weatherlink_actif: + e = lire_json(cfg.base / "var" / "etat_weatherlink.json", {}) + succes = [c.get("dernier_succes_utc") for c in e.get("comptes", {}).values() if c.get("dernier_succes_utc")] + pauses = [Pause(p, 0) for p in sorted((cfg.base / "var").glob("pause_weatherlink_*.txt"))] + actives = [p for p in pauses if p.active(maintenant)] + sources["weatherlink"] = { + "dernier_succes_utc": iso(lire_utc(max(succes))) if succes else None, + "en_pause": bool(actives), + "pause_jusqua_utc": iso(max(p.jusqua() for p in actives)) if actives else None, + "dernier_passage": ((resumes.get("weatherlink") or {}).get("action")), + } return {"mis_a_jour_utc": iso(maintenant), "sources": sources} diff --git a/tests/test_weatherlink.py b/tests/test_weatherlink.py new file mode 100644 index 0000000..1443d09 --- /dev/null +++ b/tests/test_weatherlink.py @@ -0,0 +1,195 @@ +import json +import tempfile +import unittest +import urllib.error +from pathlib import Path + +from meteo_collecte import ordonnanceur, publier, weatherlink +from meteo_collecte.commun import Config, lire_json, scrub +from meteo_collecte.stockage import Stockage +from tests.aide import FauxReseau, config, fixture, t + +CLE_A, SEC_A = "CLEALLIERES-FICTIVE", "SECRETALLIERES-FICTIF" +CLE_B, SEC_B = "CLEBRUYERES-FICTIVE", "SECRETBRUYERES-FICTIF" +APPEL = t(12, 0, jour=19) # ts des fixtures = 11:55 UTC le 19/10/2026 + +COMPTES = {"comptes": { + "allieres": {"var_cle": "MC_WL_ALLIERES_CLE", "var_secret": "MC_WL_ALLIERES_SECRET", + "stations": {"ALL": {"station_id": None, "nom": "Allières"}}}, + "bruyeres-meaudre": {"var_cle": "MC_WL_BRUYERES_CLE", "var_secret": "MC_WL_BRUYERES_SECRET", + "stations": {"B": {"station_id": "41723", "nom": "Bruyères", "altitude": 990}, + "M": {"station_id": "208771", "nom": "Méaudre"}}}}} + + +def pas_de_dormir(s): + pass + + +class Base(unittest.TestCase): + def setUp(self): + self.tmp = tempfile.TemporaryDirectory() + self.cfg, self.journal = config(self.tmp.name, weatherlink_actif=True) + self.cfg.weatherlink_comptes = Path(self.tmp.name) / "comptes.json" + self.cfg.weatherlink_comptes.write_text(json.dumps(COMPTES), encoding="utf-8") + self.cfg.env.update({"MC_WL_BRUYERES_CLE": CLE_B, "MC_WL_BRUYERES_SECRET": SEC_B}) + self.s = Stockage(Path(self.tmp.name) / "m.sqlite") + + def tearDown(self): + self.s.fermer() + self.tmp.cleanup() + + def passer(self, fetch, quand=APPEL): + return weatherlink.passer(self.cfg, self.s, self.journal, quand, fetch, pas_de_dormir) + + +class TestLecture(unittest.TestCase): + def test_conversions_iss(self): + r = weatherlink.lire_reponse(fixture("weatherlink_current_iss.json"), "K", "S", APPEL) + m = r["mesure"] + self.assertEqual(r["dh_utc"], "2026-10-19 11:55:00") + self.assertAlmostEqual(m["temperature"], 10.0) + self.assertAlmostEqual(m["point_de_rosee"], 5.0) + self.assertEqual(m["humidite"], 80.0) + self.assertAlmostEqual(m["vent_moyen"], 16.09344) + self.assertAlmostEqual(m["vent_rafales"], 32.18688) + self.assertEqual(m["vent_direction"], 10.0) # 370 -> 10 + self.assertAlmostEqual(m["pluie_cumul"], 12.7) + self.assertAlmostEqual(m["pluie_1h"], 2.54) + self.assertAlmostEqual(m["pression"], 1015.917, places=2) # capteur barométrique distinct, même station + self.assertEqual(m["rayonnement"], 300.0) + + def test_vantage_pro2_noms_anciens(self): + m = weatherlink.lire_reponse(fixture("weatherlink_current_vp2.json"), "K", "S", APPEL)["mesure"] + self.assertAlmostEqual(m["temperature"], 0.0) + self.assertEqual((m["humidite"], m["vent_direction"]), (90.0, 90.0)) + self.assertAlmostEqual(m["vent_moyen"], 8.04672) + self.assertEqual(m["pluie_cumul"], 0.0) # 0 reste 0, pas None + + def test_reponses_inutilisables(self): + for corps in (fixture("weatherlink_sans_temperature.json"), b"", b"[]", b'{"a":1}', + fixture("weatherlink_erreur.json")): + with self.assertRaises(weatherlink.ErreurWeatherLink): + weatherlink.lire_reponse(corps, "FAKEKEY123", "S", APPEL) + with self.assertRaises(weatherlink.ErreurWeatherLink) as c: + weatherlink.lire_reponse(fixture("weatherlink_erreur.json"), "FAKEKEY123", "S", APPEL) + self.assertNotIn("FAKEKEY123", str(c.exception)) + + def test_futur_refuse(self): + with self.assertRaises(weatherlink.ErreurWeatherLink): + weatherlink.lire_reponse(fixture("weatherlink_current_iss.json"), "K", "S", t(11, 0, jour=19)) + + def test_url_cle_seule_secret_en_entete(self): + u = weatherlink.construire_url("41723", "AB/C") + self.assertEqual(u, "https://api.weatherlink.com/v2/current/41723?api-key=AB%2FC") + self.assertNotIn("***", scrub(u)[:10]) + self.assertIn("api-key=***", scrub(u)) + + +class TestPassage(Base): + def test_desactive_par_defaut(self): + self.assertFalse(Config.depuis_env({}).weatherlink_actif) + self.cfg.weatherlink_actif = False + res = FauxReseau(fixture("weatherlink_current_iss.json")) + self.assertEqual(self.passer(res)["action"], "desactive") + self.assertEqual(res.urls, []) + + def test_source_distincte_et_pas_de_station_sans_id(self): + class Rec: + def __init__(s): s.appels = [] + def __call__(s, url, secret): + s.appels.append((url, secret)) + return fixture("weatherlink_current_iss.json" if "41723" in url else "weatherlink_current_vp2.json") + rec = Rec() + r = self.passer(rec) + self.assertEqual(r["requetes"], 2) + self.assertEqual(r["comptes"]["allieres"]["action"], "sans_cle") # pas de clé : aucun appel + self.assertEqual({s for _, s in rec.appels}, {SEC_B}) # secret en en-tête, jamais en URL + self.assertTrue(all(SEC_B not in u and "api-key=" + CLE_B in u for u, _ in rec.appels)) + self.assertEqual(self.s.compter("weatherlink"), 2) + self.assertEqual(self.s.compter("infoclimat") + self.s.compter("romma"), 0) + self.assertAlmostEqual(self.s.derniere("weatherlink", "41723")["temperature"], 10.0) + st = {x["station_id"]: x for x in self.s.stations()} + self.assertEqual(st["41723"]["source"], "weatherlink") + self.assertIn("bruyeres-meaudre", st["41723"]["extra"]) + + def test_station_id_manquant_ignoree(self): + self.cfg.env.update({"MC_WL_ALLIERES_CLE": CLE_A, "MC_WL_ALLIERES_SECRET": SEC_A}) + res = FauxReseau(fixture("weatherlink_current_iss.json")) + r = self.passer(lambda u, s: res(u)) + self.assertEqual(r["comptes"]["allieres"]["ignorees"], ["ALL"]) + self.assertEqual(r["comptes"]["allieres"]["requetes"], 0) + + def test_cache_dix_minutes(self): + res = FauxReseau(fixture("weatherlink_current_iss.json")) + f = lambda u, s: res(u) + self.passer(f) + self.assertEqual(len(res.urls), 2) + self.assertEqual(self.passer(f, t(12, 5, jour=19))["requetes"], 0) # moins de 10 min : cache + self.assertEqual(len(res.urls), 2) + self.passer(f, t(12, 11, jour=19)) + self.assertEqual(len(res.urls), 4) + + def test_plafond_horaire_propre(self): + self.cfg.wl_max_heure = 1 + res = FauxReseau(fixture("weatherlink_current_iss.json")) + r = self.passer(lambda u, s: res(u)) + self.assertEqual(len(res.urls), 1) + self.assertEqual(r["comptes"]["bruyeres-meaudre"]["action"], "plafond_heure") + + def test_erreur_http_pause_et_secrets_masques(self): + def f(url, secret): + raise urllib.error.HTTPError(url, 429, "Too Many Requests " + SEC_B, {}, None) + r = self.passer(f) + self.assertEqual(r["comptes"]["bruyeres-meaudre"]["action"], "erreur") + self.assertEqual(r["requetes"], 1) # le compte s'arrête net + texte = (self.cfg.base / "var" / "journal.log").read_text(encoding="utf-8") + for secret in (CLE_B, SEC_B): + self.assertNotIn(secret, texte) + self.assertNotIn(secret, json.dumps(r)) + res = FauxReseau(fixture("weatherlink_current_iss.json")) + r2 = self.passer(lambda u, s: res(u), t(12, 30, jour=19)) # 429 : pause 1 h + self.assertEqual(r2["comptes"]["bruyeres-meaudre"]["action"], "pause") + self.assertEqual(res.urls, []) + self.assertEqual(self.passer(lambda u, s: res(u), t(13, 1, jour=19))["requetes"], 2) + + def test_ne_touche_pas_le_quota_infoclimat(self): + res = FauxReseau(fixture("weatherlink_current_iss.json")) + self.passer(lambda u, s: res(u)) + self.assertFalse(self.cfg.quota_commun.exists()) + self.assertFalse((self.cfg.base / "var" / "etat_romma.json").exists()) + + +class TestIntegration(Base): + def test_tick_et_publication(self): + self.cfg.env.update({"MC_ROMMA_ACTIF": "0"}) + self.cfg.romma_actif = self.cfg.infoclimat_actif = False + res = FauxReseau(fixture("weatherlink_current_iss.json")) + ordonnanceur.tick(self.cfg, APPEL, fetch_weatherlink=lambda u, s: res(u), dormir_weatherlink=pas_de_dormir) + data = self.cfg.public / "data" + idx = lire_json(data / "stations.json", {}) + par = {x["id"]: x for x in idx["stations"]} + self.assertEqual(set(par), {"weatherlink-41723", "weatherlink-208771"}) + self.assertEqual(par["weatherlink-41723"]["source"], "weatherlink") + self.assertIn("Station Gastinel", par["weatherlink-41723"]["attribution"]) + self.assertIn("weatherlink", lire_json(data / "etat.json", {})["sources"]) + for p in data.rglob("*.json"): + texte = p.read_text(encoding="utf-8") + for secret in (CLE_B, SEC_B, "api-key"): + self.assertNotIn(secret, texte) + + def test_tick_desactive_ne_publie_pas_la_source(self): + self.cfg.weatherlink_actif = False + self.cfg.romma_actif = self.cfg.infoclimat_actif = False + ordonnanceur.tick(self.cfg, APPEL) + self.assertNotIn("weatherlink", lire_json(self.cfg.public / "data" / "etat.json", {})["sources"]) + + def test_fichier_de_comptes_du_depot_sans_valeur_secrete(self): + brut = (Path(__file__).resolve().parent.parent / "config" / "weatherlink.json").read_text(encoding="utf-8") + comptes = json.loads(brut)["comptes"] + for c in comptes.values(): + self.assertTrue(c["var_cle"].startswith("MC_WL_") and c["var_secret"].startswith("MC_WL_")) + self.assertEqual(len({c["var_cle"] for c in comptes.values()}), len(comptes)) # une clé par compte + + +if __name__ == "__main__": + unittest.main()