172 lignes
7.8 KiB
Python
172 lignes
7.8 KiB
Python
"""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()
|