Collecteur ROMMA direct (Engins, Die, Saint-Julien-en-Quint, Archiane) : un appel par passage, garde-fou de 10 min, simulation par défaut

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
Théo GastineletClaude Opus 5.5 a révisé 2026-11-05 11:15:01 +01:00
1 Parent 2dfe5dada7
révision 518abc0708
3 fichiers modifiés
+547

Aucun fichier ne correspond à votre recherche

+350
Voir le fichier
@@ -0,0 +1,350 @@
#!/usr/bin/env python3
"""Collecte ROMMA (api_export.php, type=live) -> JSON public filtré (public/data/romma.json).
Stations autorisées par ROMMA (accord du 24/10/2026 : « une requête toutes les 10 minutes convient », pas
d'historique via l'API, ROMMA cité) : Engins (139), Die (159), Saint-Julien-en-Quint (158), Cirque d'Archiane (212).
Un SEUL appel par passage (global=1 renvoie toutes les stations de la clé, on ne garde que les 4).
Garde-fou : jamais plus d'un appel par 10 minutes (horodatage « pas_avant_utc » écrit AVANT l'appel).
Même format que meteofrance.json / infoclimat.json. ROMMA ne donne que le relevé courant : on accumule
nos propres passages sur 24 h (pas d'historique demandé à ROMMA). Erreur : relevés précédents gardés.
Mode SIMULATION par défaut (aucun réseau, données factices, n'écrit que si --sortie est donné).
Mode --reel : exige ROMMA_APPEL_RESEAU_VALIDE=oui, ROMMA_CLE, ROMMA_URL_API (avec le marqueur {cle}) ;
variables d'environnement, sinon fichier ~/.config/meteo-vercors/romma.env (NOM=valeur). La clé n'est jamais
affichée, ni écrite ailleurs.
Usage :
python collecter_romma.py --sortie /tmp/essai.json # simulation
python collecter_romma.py --reel # un appel réel (si le délai de 10 min est passé)
"""
import argparse
import datetime as dt
import json
import os
import re
import sys
import urllib.error
import urllib.request
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from collecter_weatherlink import CHAMPS_PUBLICS, charger_json, ecrire_atomique, fmt_utc, maintenant, verifier_public # noqa: E402
UTC = dt.timezone.utc
SOURCE_ROMMA = "ROMMA"
MENTION = "Source des données : ROMMA (Réseau d'Observation Météo du Massif Alpin) - www.romma.fr"
UA = "vercors.me/0.1 (meteo-vercors)"
RACINE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
SORTIE_DEFAUT = os.path.join(RACINE, "public", "data", "romma.json")
ENV_DEFAUT = "~/.config/meteo-vercors/romma.env"
ETAT_DEFAUT = "~/.config/meteo-vercors/romma_etat.json"
INTERVALLE_S = 600 # plancher entre deux appels
PAUSE_CLE_REFUSEE_S = 3600
HORS_LIGNE_MIN = 40
# id du site -> (numéro ROMMA, nom). Les numéros sont ceux de l'autorisation ; rien d'autre n'est conservé.
STATIONS = {
"engins": (139, "Engins"),
"die": (159, "Die"),
"st-julien-q": (158, "Saint-Julien-en-Quint"),
"archiane": (212, "Cirque d'Archiane"),
}
# [À VÉRIFIER auprès de ROMMA] unité du vent : on suppose des km/h. Si m/s, mettre 3.6.
FACTEUR_VENT = 1.0
ROSE = {n: i * 22.5 for i, n in enumerate("N NNE NE ENE E ESE SE SSE S SSO SO OSO O ONO NO NNO".split())}
class ErreurRomma(Exception):
pass
class CleRefusee(ErreurRomma):
pass
# ------------------------------------------------------------------ heure de Paris (sans tzdata)
def _dernier_dimanche(annee, mois):
d = dt.date(annee, mois, 31)
return d - dt.timedelta(days=(d.weekday() + 1) % 7)
def paris_vers_utc(local):
"""datetime naïf (heure de Paris) -> UTC. None si l'heure n'existe pas (saut de mars)."""
debut = dt.datetime.combine(_dernier_dimanche(local.year, 3), dt.time(1), UTC)
fin = dt.datetime.combine(_dernier_dimanche(local.year, 10), dt.time(1), UTC)
ete = (local - dt.timedelta(hours=2)).replace(tzinfo=UTC)
if debut <= ete < fin:
return ete
hiver = (local - dt.timedelta(hours=1)).replace(tzinfo=UTC)
return hiver if (hiver < debut or hiver >= fin) else None
# ------------------------------------------------------------------ clé et réglages
def lire_env(fichier):
"""Lit NOM=valeur du fichier (si présent), puis l'environnement l'emporte. Rien n'est affiché."""
out = {}
try:
with open(os.path.expanduser(fichier), encoding="utf-8") as f:
for ligne in f:
nom, sep, val = ligne.strip().partition("=")
if sep and not nom.startswith("#"):
out[nom.strip()] = val.strip().strip('"').strip("'")
except OSError:
pass
for nom in ("ROMMA_CLE", "ROMMA_URL_API", "ROMMA_APPEL_RESEAU_VALIDE"):
if os.environ.get(nom):
out[nom] = os.environ[nom]
return out
def masquer(t, cle):
return t.replace(cle, "***") if cle else t
def appeler(url_modele, cle, ouvrir=None):
"""UN appel. La clé n'apparaît dans aucun message d'erreur."""
req = urllib.request.Request(url_modele.replace("{cle}", cle), headers={"User-Agent": UA, "Accept": "application/json"})
try:
with (ouvrir or urllib.request.urlopen)(req, timeout=30) as r:
return r.read()
except urllib.error.HTTPError as e:
raise ErreurRomma("HTTP %d" % e.code)
except Exception as e:
raise ErreurRomma("réseau : %s" % type(e).__name__)
# ------------------------------------------------------------------ lecture de la réponse
def nombre(o, cle):
v = o.get(cle)
if isinstance(v, bool) or v is None:
return None
if isinstance(v, (int, float)):
return float(v)
if isinstance(v, str):
s = v.strip()
if not s or s.upper() == "NULL":
return None
try:
return float(s.replace(",", "."))
except ValueError:
return None
return None
def texte(o, cle):
v = o.get(cle)
if isinstance(v, (int, float)) and not isinstance(v, bool):
return str(int(v)) if float(v).is_integer() else str(v)
if isinstance(v, str) and v.strip() and v.strip().upper() != "NULL":
return v.strip()
return None
def lire_date_heure(date, heure):
m = re.fullmatch(r"\s*(\d{1,2})/(\d{1,2})/(\d{2}|\d{4})\s*", date or "")
h = re.fullmatch(r"\s*(\d{1,2}):(\d{2})(?::(\d{2}))?\s*", heure or "")
if not m or not h:
return None
a = int(m.group(3))
try:
return dt.datetime(a + 2000 if a < 100 else a, int(m.group(2)), int(m.group(1)),
int(h.group(1)), int(h.group(2)), int(h.group(3) or 0))
except ValueError:
return None
def parser_reponse(corps, fin, cle=""):
"""Réponse brute -> ({id_site: (relevé public, métadonnées)}, avertissements). Lève ErreurRomma / CleRefusee.
Ne garde que les 4 stations autorisées ; ignore les mesures invalides, sans température ou dans le futur."""
if isinstance(corps, bytes):
corps = corps.decode("utf-8", errors="replace")
try:
valeur = json.loads(corps.strip().lstrip(""))
except ValueError:
raise ErreurRomma("réponse non JSON")
if isinstance(valeur, str):
bas = valeur.lower()
if "apikey invalid" in bas or "no user associated" in bas:
raise CleRefusee("clé refusée")
raise ErreurRomma(masquer(valeur, cle)[:120])
if not isinstance(valeur, list):
raise ErreurRomma("tableau de stations attendu")
par_numero = {str(n): sid for sid, (n, _) in STATIONS.items()}
out, avert = {}, []
for o in valeur:
sid = par_numero.get(texte(o, "id_station") or "") if isinstance(o, dict) else None
if not sid:
continue # station hors autorisation : jamais conservée
if not (nombre(o, "is_valide") or 0):
avert.append("%s : is_valide=0" % sid)
continue
loc = lire_date_heure(texte(o, "date"), texte(o, "heure"))
d = paris_vers_utc(loc) if loc else None
if d is None:
avert.append("%s : date/heure inutilisable" % sid)
continue
if (d - fin).total_seconds() > 900:
avert.append("%s : mesure dans le futur" % sid)
continue
t = nombre(o, "temperature")
if t is None:
avert.append("%s : pas de température" % sid)
continue
r = {"dh_utc": fmt_utc(d), "temperature": round(t, 1)}
h, p = nombre(o, "humidite"), nombre(o, "pression")
v, raf = nombre(o, "vent_moyen_10min"), nombre(o, "vent_rafale_maxi_10min")
deg = nombre(o, "vent_direction_degres")
if deg is None:
deg = ROSE.get((texte(o, "vent_direction") or "").upper())
pj = nombre(o, "pluie_jour")
if h is not None:
r["humidite"] = int(round(h))
if p is not None:
r["pression"] = round(p, 1)
if v is not None:
r["vent_moyen"] = round(v * FACTEUR_VENT, 1)
if raf is not None:
r["vent_rafales"] = round(raf * FACTEUR_VENT, 1)
if deg is not None and v:
r["vent_direction"] = int(round(deg)) % 360
if pj is not None:
r["pluie_cumul_0h"] = round(pj, 1)
meta = {"licence": SOURCE_ROMMA}
lat, lon, alt = nombre(o, "latitude"), nombre(o, "longitude"), nombre(o, "altitude")
if lat is not None and lon is not None:
meta["lat"], meta["lon"] = round(lat, 2), round(lon, 2)
if alt is not None:
meta["altitude"] = int(round(alt))
out[sid] = (r, meta)
return out, avert
# ------------------------------------------------------------------ assemblage
def lire_dh(s):
return dt.datetime.strptime(s[:19].replace("T", " "), "%Y-%m-%d %H:%M:%S").replace(tzinfo=UTC)
def construire(precedent, nouveaux, fin, heures=24):
"""Ancien JSON + relevés du passage -> (nouveau JSON, journal). Sans nouveauté, la station garde ses relevés."""
anciens = (precedent or {}).get("stations") or {}
metas = dict((precedent or {}).get("metadonnees") or {})
debut = fin - dt.timedelta(hours=heures)
stations, journal = {}, []
for sid, (_, nom) in STATIONS.items():
par_date = {}
for r in (anciens.get(sid) or {}).get("releves") or []:
if isinstance(r, dict) and isinstance(r.get("dh_utc"), str):
par_date[r["dh_utc"]] = {k: r[k] for k in CHAMPS_PUBLICS
if k in r and k not in ("temperature_min", "temperature_max")}
if sid in nouveaux:
r, meta = nouveaux[sid]
par_date[r["dh_utc"]] = r
metas[sid] = {**metas.get(sid, {}), **meta}
metas.setdefault(sid, {"licence": SOURCE_ROMMA})
rel = [par_date[d] for d in sorted(par_date) if lire_dh(d) > debut]
if rel:
ts = [r["temperature"] for r in rel]
rel[-1]["temperature_min"], rel[-1]["temperature_max"] = min(ts), max(ts)
hors = not rel or fin - lire_dh(rel[-1]["dh_utc"]) > dt.timedelta(minutes=HORS_LIGNE_MIN)
stations[sid] = {"nom": nom, "source": SOURCE_ROMMA, "hors_ligne": hors, "releves": rel}
journal.append("%s: %s (%d relevés)" % (sid, "nouveau" if sid in nouveaux else "pas de nouveau", len(rel)))
obj = {"source": MENTION, "mis_a_jour_utc": fin.strftime("%Y-%m-%dT%H:%M:%SZ"),
"metadonnees": {sid: metas[sid] for sid in STATIONS}, "stations": stations}
return obj, journal
# ------------------------------------------------------------------ garde-fou 10 minutes
def reserver_passage(etat_chemin, fin, secondes=INTERVALLE_S):
"""(True, None) si un appel est permis ; écrit alors « pas_avant_utc » AVANT l'appel (un plantage ne le rejoue pas)."""
etat = charger_json(etat_chemin) if etat_chemin else {}
jusque = etat.get("pas_avant_utc")
if jusque:
try:
if fin < lire_dh(jusque):
return False, jusque
except ValueError:
pass
if etat_chemin:
etat["pas_avant_utc"] = fmt_utc(fin + dt.timedelta(seconds=secondes))
ecrire_atomique(etat_chemin, etat)
return True, None
def repousser(etat_chemin, fin, secondes, message):
if etat_chemin:
etat = charger_json(etat_chemin)
etat["pas_avant_utc"] = fmt_utc(fin + dt.timedelta(seconds=secondes))
etat["derniere_erreur"] = message[:120]
ecrire_atomique(etat_chemin, etat)
# ------------------------------------------------------------------ simulation
def reponse_factice(fin):
loc = (fin + dt.timedelta(hours=1)).replace(tzinfo=None) # simulation seulement : heure d'hiver
out = []
for i, (sid, (num, nom)) in enumerate(STATIONS.items()):
out.append({"id_station": num, "station": nom, "altitude": 500 + 100 * i, "latitude": 44.8 + i / 10,
"longitude": 5.4, "is_valide": 1, "date": loc.strftime("%d/%m/%y"), "heure": loc.strftime("%H:%M"),
"temperature": 7.5 + i, "pression": 1012.3, "humidite": "NULL", "radiation": "NULL",
"vent_moyen_10min": 12 + i, "vent_rafale_maxi_10min": 30, "vent_direction": "SSO",
"vent_direction_degres": 202, "pluie_jour": "0.4", "neige": "NULL"})
out.append({"id_station": 4, "station": "Hors autorisation", "is_valide": 1, "temperature": 3,
"date": loc.strftime("%d/%m/%y"), "heure": loc.strftime("%H:%M")})
return json.dumps(out).encode()
# ------------------------------------------------------------------ programme
def passage(precedent, fetch, fin, cle="", etat_chemin=None):
"""Un passage complet. fetch() -> corps brut. -> (objet à écrire ou None, message, code).
Erreur : relevés précédents gardés (objet reconstruit sans nouveauté)."""
ok, jusque = reserver_passage(etat_chemin, fin)
if not ok:
return None, "attente : prochain appel permis après %s UTC" % jusque, 0
try:
nouveaux, avert = parser_reponse(fetch(), fin, cle)
except ErreurRomma as e:
msg = masquer(str(e), cle)
repousser(etat_chemin, fin, PAUSE_CLE_REFUSEE_S if isinstance(e, CleRefusee) else INTERVALLE_S, msg)
if precedent:
obj, journal = construire(precedent, {}, fin)
return obj, "erreur (%s), relevés précédents gardés ; %s" % (msg, "; ".join(journal)), 0
return None, "erreur (%s), rien à garder" % msg, 1
obj, journal = construire(precedent, nouveaux, fin)
return obj, "ok ; " + "; ".join(journal + avert), 0
def main(argv=None):
ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
ap.add_argument("--reel", action="store_true", help="appel réseau réel (garde-fous requis) ; défaut : simulation")
ap.add_argument("--sortie", default=None, help="défaut en réel : public/data/romma.json ; en simulation : rien n'est écrit")
ap.add_argument("--fichier-env", default=ENV_DEFAUT)
ap.add_argument("--etat", default=None, help="fichier d'horodatage du garde-fou (défaut réel : %s)" % ETAT_DEFAUT)
a = ap.parse_args(argv)
fin = maintenant()
cle, etat = "", a.etat
if a.reel:
env = lire_env(a.fichier_env)
cle, url = env.get("ROMMA_CLE", ""), env.get("ROMMA_URL_API", "")
if env.get("ROMMA_APPEL_RESEAU_VALIDE") != "oui":
print("refusé : ROMMA_APPEL_RESEAU_VALIDE=oui non déclaré (validation de Théo)")
return 2
if not cle or "{cle}" not in url:
print("refusé : ROMMA_CLE et ROMMA_URL_API (avec {cle}) requises dans %s" % a.fichier_env)
return 2
sortie = a.sortie or SORTIE_DEFAUT
etat = etat or os.path.expanduser(ETAT_DEFAUT)
fetch = lambda: appeler(url, cle) # noqa: E731
else:
sortie = a.sortie
fetch = lambda: reponse_factice(fin) # noqa: E731
precedent = charger_json(sortie) if sortie else {}
obj, msg, code = passage(precedent, fetch, fin, cle, etat)
if obj is not None:
verifier_public(obj)
if sortie:
ecrire_atomique(sortie, obj)
print(("" if a.reel else "[simulation] ") + msg)
return code
if __name__ == "__main__":
sys.exit(main())
+26
Voir le fichier
@@ -0,0 +1,26 @@
#!/bin/bash
# Enregistre la clé ROMMA sans l'afficher, dans ~/.config/meteo-vercors/romma.env (droits 600).
# Usage : bash poser_cle_romma.sh
# Ne pose PAS ROMMA_APPEL_RESEAU_VALIDE : c'est à Théo de le déclarer, à la main, le jour du premier appel réel.
set -eu
f=~/.config/meteo-vercors/romma.env
mkdir -p "$(dirname "$f")"
read -rsp "Colle la clé ROMMA puis Entrée : " K; echo
[ -n "$K" ] || { echo "Clé vide : rien n'a changé."; exit 1; }
# URL de l'API, avec {cle} à la place de la clé (jamais la clé elle-même). Entrée vide = valeur actuelle,
# sinon celle relevée dans le code de GWS (non documentée publiquement, à confirmer auprès de ROMMA).
defaut='https://www.romma.fr/api_export.php/?apikey={cle}&type=live&global=1'
actuelle="$(grep '^ROMMA_URL_API=' "$f" 2>/dev/null | cut -d= -f2- || true)"
echo "URL actuelle : ${actuelle:-(aucune)}"
read -rp "URL avec {cle} [Entrée = ${actuelle:-$defaut}] : " U
U="${U:-${actuelle:-$defaut}}"
case "$U" in *'{cle}'*) ;; *) echo "L'URL doit contenir {cle} : rien n'a changé."; exit 1;; esac
umask 077
touch "$f"
{ grep -v -e '^ROMMA_CLE=' -e '^ROMMA_URL_API=' "$f" || true; } > "$f.tmp"
printf 'ROMMA_CLE=%s\nROMMA_URL_API=%s\n' "$K" "$U" >> "$f.tmp"
mv "$f.tmp" "$f"
chmod 600 "$f"
echo "ok : ROMMA_CLE enregistrée (${#K} caractères) et ROMMA_URL_API dans $f"
echo "Étape suivante (à toi, après ton feu vert) : ajouter la ligne ROMMA_APPEL_RESEAU_VALIDE=oui dans ce fichier, puis"
echo " python3 collecter_romma.py --reel # UN appel ; un 2e lancement avant 10 min est refusé par le garde-fou"
+171
Voir le fichier
@@ -0,0 +1,171 @@
"""Tests du collecteur ROMMA, sans réseau : python -m unittest discover -s tests"""
import contextlib
import datetime as dt
import io
import json
import os
import sys
import tempfile
import unittest
sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "collecte"))
import collecter_romma as cr # noqa: E402
from collecter_weatherlink import verifier_public # noqa: E402
FIN = dt.datetime(2026, 11, 5, 10, 0, tzinfo=dt.timezone.utc) # 11:00 à Paris (hiver)
CLE = "CLE-SECRETE-XYZ"
def ligne(num, heure="10:55", **kw):
o = {"id_station": num, "station": "S%s" % num, "altitude": 1000, "latitude": 44.91, "longitude": 5.43,
"is_valide": 1, "date": "05/11/26", "heure": heure, "temperature": "5,5", "pression": 1010,
"humidite": "NULL", "vent_moyen_10min": 10, "vent_rafale_maxi_10min": 25, "vent_direction": "SSO",
"vent_direction_degres": 200, "pluie_jour": "1.2"}
o.update(kw)
return o
def corps(*lignes):
return json.dumps(list(lignes)).encode()
class TestRomma(unittest.TestCase):
def test_parse_filtre_et_unites(self):
r, _ = cr.parser_reponse(corps(ligne(139), ligne(4), ligne(159, humidite="80")), FIN)
self.assertEqual(set(r), {"engins", "die"}) # station 4 hors autorisation
rel = r["engins"][0]
self.assertEqual(rel["dh_utc"], "2026-11-05 09:55:00")
self.assertEqual((rel["temperature"], rel["vent_moyen"], rel["vent_direction"], rel["pluie_cumul_0h"]),
(5.5, 10.0, 200, 1.2))
self.assertNotIn("humidite", rel)
self.assertEqual(r["die"][0]["humidite"], 80)
self.assertEqual(r["engins"][1]["lat"], 44.91)
def test_ignores(self):
r, av = cr.parser_reponse(corps(ligne(139, is_valide=0), ligne(159, temperature="NULL"),
ligne(158, heure="12:30"), ligne(212, date="xx")), FIN)
self.assertEqual(r, {})
self.assertEqual(len(av), 4)
def test_cle_refusee_et_reponse_invalide(self):
with self.assertRaises(cr.CleRefusee):
cr.parser_reponse(json.dumps("Erreur : no user associated or apikey invalid"), FIN)
with self.assertRaises(cr.ErreurRomma):
cr.parser_reponse("<html>", FIN)
def test_sortie_publique(self):
r, _ = cr.parser_reponse(cr.reponse_factice(FIN), FIN)
obj, _ = cr.construire({}, r, FIN)
verifier_public(obj)
self.assertEqual(set(obj["stations"]), set(cr.STATIONS))
self.assertEqual(obj["stations"]["die"]["source"], "ROMMA")
self.assertFalse(obj["stations"]["die"]["hors_ligne"])
self.assertNotIn("Hors autorisation", json.dumps(obj))
def test_accumulation_et_fenetre(self):
prec, _ = cr.construire({}, cr.parser_reponse(corps(ligne(139, heure="10:50", temperature=2)), FIN)[0], FIN)
r2, _ = cr.parser_reponse(corps(ligne(139, heure="10:55", temperature=8)), FIN)
obj, _ = cr.construire(prec, r2, FIN)
rel = obj["stations"]["engins"]["releves"]
self.assertEqual(len(rel), 2)
self.assertEqual((rel[-1]["temperature_min"], rel[-1]["temperature_max"]), (2.0, 8.0))
obj2, _ = cr.construire(obj, {}, FIN + dt.timedelta(hours=25)) # hors fenêtre de 24 h
self.assertEqual(obj2["stations"]["engins"]["releves"], [])
self.assertTrue(obj2["stations"]["engins"]["hors_ligne"])
def test_erreur_garde_precedent(self):
prec, _ = cr.construire({}, cr.parser_reponse(cr.reponse_factice(FIN), FIN)[0], FIN)
def casse():
raise cr.ErreurRomma("HTTP 500")
obj, msg, code = cr.passage(prec, casse, FIN + dt.timedelta(minutes=5), CLE, None)
self.assertEqual(code, 0)
self.assertEqual(len(obj["stations"]["die"]["releves"]), 1)
self.assertIn("précédents gardés", msg)
obj, msg, code = cr.passage({}, casse, FIN, CLE, None)
self.assertEqual((obj, code), (None, 1))
def test_garde_fou_10_minutes(self):
with tempfile.TemporaryDirectory() as d:
etat = os.path.join(d, "etat.json")
appels = []
def f():
appels.append(1)
return cr.reponse_factice(FIN)
self.assertIsNotNone(cr.passage({}, f, FIN, CLE, etat)[0])
obj, msg, _ = cr.passage({}, f, FIN + dt.timedelta(minutes=9), CLE, etat)
self.assertIsNone(obj)
self.assertIn("attente", msg)
self.assertEqual(len(appels), 1) # un seul appel pour les 4 stations
cr.passage({}, f, FIN + dt.timedelta(minutes=10, seconds=1), CLE, etat)
self.assertEqual(len(appels), 2)
def test_garde_fou_apres_erreur_et_cle_refusee(self):
with tempfile.TemporaryDirectory() as d:
etat = os.path.join(d, "etat.json")
def refuse():
raise cr.CleRefusee("clé refusée")
cr.passage({}, refuse, FIN, CLE, etat)
obj, msg, _ = cr.passage({}, refuse, FIN + dt.timedelta(minutes=30), CLE, etat)
self.assertIsNone(obj)
self.assertIn("attente", msg) # clé refusée : pause d'une heure
def test_main_refuse_sans_validation_et_n_affiche_pas_la_cle(self):
with tempfile.TemporaryDirectory() as d:
env = os.path.join(d, "romma.env")
with open(env, "w") as f:
f.write("ROMMA_CLE=%s\nROMMA_URL_API=https://exemple.invalide/?k={cle}\n" % CLE)
for k in ("ROMMA_CLE", "ROMMA_URL_API", "ROMMA_APPEL_RESEAU_VALIDE"):
os.environ.pop(k, None)
sortie = io.StringIO()
with contextlib.redirect_stdout(sortie):
code = cr.main(["--reel", "--fichier-env", env, "--sortie", os.path.join(d, "r.json"),
"--etat", os.path.join(d, "e.json")])
self.assertEqual(code, 2) # validation absente : aucun appel
self.assertNotIn(CLE, sortie.getvalue())
self.assertFalse(os.path.exists(os.path.join(d, "r.json")))
def test_main_reel_erreur_reseau_masque_la_cle(self):
with tempfile.TemporaryDirectory() as d:
env = os.path.join(d, "romma.env")
with open(env, "w") as f:
f.write("ROMMA_CLE=%s\nROMMA_URL_API=https://exemple.invalide/?k={cle}\n"
"ROMMA_APPEL_RESEAU_VALIDE=oui\n" % CLE)
appels = []
def ouvrir(req, timeout=0):
appels.append(req.full_url)
raise OSError("échec " + req.full_url)
vrai = cr.urllib.request.urlopen
cr.urllib.request.urlopen = ouvrir
try:
sortie = io.StringIO()
with contextlib.redirect_stdout(sortie):
code = cr.main(["--reel", "--fichier-env", env, "--sortie", os.path.join(d, "r.json"),
"--etat", os.path.join(d, "e.json")])
code2 = cr.main(["--reel", "--fichier-env", env, "--sortie", os.path.join(d, "r.json"),
"--etat", os.path.join(d, "e.json")])
finally:
cr.urllib.request.urlopen = vrai
self.assertEqual((code, code2), (1, 0))
self.assertEqual(len(appels), 1) # le 2e passage est bloqué par le garde-fou
self.assertNotIn(CLE, sortie.getvalue())
def test_simulation_par_defaut(self):
with contextlib.redirect_stdout(io.StringIO()) as s:
self.assertEqual(cr.main([]), 0) # sans --sortie : rien n'est écrit
self.assertIn("[simulation]", s.getvalue())
def test_lire_env(self):
with tempfile.TemporaryDirectory() as d:
env = os.path.join(d, "e")
with open(env, "w") as f:
f.write("# c\nROMMA_CLE=\"abc\"\n")
os.environ.pop("ROMMA_CLE", None)
self.assertEqual(cr.lire_env(env)["ROMMA_CLE"], "abc")
if __name__ == "__main__":
unittest.main()