grabowski
32399f1899
The first ntfy cycle announced "Warning level at P.77" at 3.02 m. That gauge's 2.85 m threshold sat below its own dry-season baseline (2.6-2.7 m at 8-14 % channel capacity): P.77 had been "above warning" for 761 of the last 2 146 hours, at 22 % capacity. Across 2018-2024, 75-85 % capacity reads 3.35-4.57 m and 95-105 % reads 4.27-5.08 m; set 4.30 / 4.90. P.75 moved 2.75/3.50 -> 3.20/3.65 on the same evidence (2024: 3.45 / 3.72). The predictor already handles changed thresholds (regression-derived probabilities until the Oct 1 retrain). Second line of defence in notify.py: a clear->alert transition is only announced when RID's discharge_percent for the reading is >= 60 %, so a re-rated or datum-shifted gauge cannot page subscribers again. P.1 is exempt (its stages come from the inundation map, not capacity); readings without a capacity figure fall back to level only; the all-clear edge is never blocked. 3 tests.
286 lines
8.7 KiB
Python
286 lines
8.7 KiB
Python
"""ntfy notification state machine: transitions only, hysteresis, restart-safe."""
|
|
|
|
import datetime
|
|
|
|
import pytest
|
|
|
|
from src import notify
|
|
|
|
|
|
class FakePublisher(notify.NtfyPublisher):
|
|
def __init__(self):
|
|
super().__init__("http://ntfy.test", prefix="ping")
|
|
self.sent = []
|
|
|
|
def publish(self, n):
|
|
self.sent.append(n)
|
|
return True
|
|
|
|
|
|
@pytest.fixture
|
|
def pub():
|
|
return FakePublisher()
|
|
|
|
|
|
def _reading(code, level, ts="2026-09-24T12:00:00"):
|
|
return {"station_code": code, "water_level": level, "timestamp": ts}
|
|
|
|
|
|
def _fc(p, peak=None):
|
|
return [
|
|
{
|
|
"station_code": "P.1",
|
|
"horizon_hours": 24,
|
|
"p_warning": p,
|
|
"predicted_max_level": peak,
|
|
"source": "model",
|
|
}
|
|
]
|
|
|
|
|
|
NOW = datetime.datetime(2026, 9, 24, 12, 30)
|
|
|
|
|
|
def topics(pub):
|
|
return [n.topic for n in pub.sent]
|
|
|
|
|
|
def test_quiet_river_sends_nothing(pub):
|
|
state = notify.InMemoryState()
|
|
for h in range(48):
|
|
notify.evaluate(
|
|
[_reading("P.1", 1.6), _reading("P.103", 3.2)],
|
|
_fc(0.01),
|
|
state,
|
|
pub,
|
|
now=NOW,
|
|
)
|
|
assert pub.sent == []
|
|
|
|
|
|
def test_warning_crossing_once_then_silence_then_clear(pub):
|
|
state = notify.InMemoryState()
|
|
# rising through 3.70 (P.1 warning)
|
|
notify.evaluate([_reading("P.1", 3.65)], [], state, pub, now=NOW)
|
|
assert pub.sent == []
|
|
notify.evaluate([_reading("P.1", 3.72)], [], state, pub, now=NOW)
|
|
assert topics(pub) == ["ping-p1-warning", "ping-warning"]
|
|
assert pub.sent[0].priority == 4 and "3.72 m" in pub.sent[0].message
|
|
# stays above: no repeats for many hours
|
|
for level in (3.80, 3.95, 4.05, 3.90, 3.75):
|
|
notify.evaluate([_reading("P.1", level)], [], state, pub, now=NOW)
|
|
assert len(pub.sent) == 2
|
|
# dips to 3.65: within hysteresis, still no message
|
|
notify.evaluate([_reading("P.1", 3.65)], [], state, pub, now=NOW)
|
|
assert len(pub.sent) == 2
|
|
# 3.55: clear
|
|
notify.evaluate([_reading("P.1", 3.55)], [], state, pub, now=NOW)
|
|
assert topics(pub)[2:] == ["ping-p1-warning", "ping-warning"]
|
|
assert "back to normal" in pub.sent[2].title
|
|
|
|
|
|
def test_danger_escalation_and_deescalation(pub):
|
|
state = notify.InMemoryState()
|
|
notify.evaluate([_reading("P.1", 3.9)], [], state, pub, now=NOW) # warning
|
|
notify.evaluate(
|
|
[_reading("P.1", 4.25)], [], state, pub, now=NOW
|
|
) # danger (>= 4.20)
|
|
assert topics(pub) == [
|
|
"ping-p1-warning",
|
|
"ping-warning",
|
|
"ping-p1-danger",
|
|
"ping-danger",
|
|
]
|
|
assert pub.sent[2].priority == 5
|
|
notify.evaluate(
|
|
[_reading("P.1", 4.15)], [], state, pub, now=NOW
|
|
) # hysteresis: still danger
|
|
assert len(pub.sent) == 4
|
|
notify.evaluate([_reading("P.1", 4.05)], [], state, pub, now=NOW) # back to warning
|
|
assert topics(pub)[4:] == ["ping-p1-danger", "ping-warning"]
|
|
assert "below danger" in pub.sent[4].title
|
|
|
|
|
|
def test_jump_straight_to_danger(pub):
|
|
state = notify.InMemoryState()
|
|
notify.evaluate(
|
|
[_reading("P.103", 7.0)], [], state, pub, now=NOW
|
|
) # P.103 danger 6.75
|
|
assert topics(pub) == ["ping-p103-danger", "ping-danger"]
|
|
|
|
|
|
def test_basin_digest_groups_stations(pub):
|
|
state = notify.InMemoryState()
|
|
notify.evaluate(
|
|
[_reading("P.1", 3.8), _reading("P.103", 6.0), _reading("P.67", 1.0)],
|
|
[],
|
|
state,
|
|
pub,
|
|
now=NOW,
|
|
)
|
|
basin = [n for n in pub.sent if n.topic == "ping-warning"]
|
|
assert len(basin) == 1 and "P.1" in basin[0].message and "P.103" in basin[0].message
|
|
|
|
|
|
def test_outlook_on_off_with_hysteresis(pub):
|
|
state = notify.InMemoryState()
|
|
r = [_reading("P.1", 2.9)]
|
|
notify.evaluate(r, _fc(0.30), state, pub, now=NOW)
|
|
assert pub.sent == []
|
|
notify.evaluate(r, _fc(0.55, 3.9), state, pub, now=NOW)
|
|
assert topics(pub) == ["ping-p1-outlook"]
|
|
assert "55%" in pub.sent[0].message and "3.90 m" in pub.sent[0].message
|
|
assert "not an official warning" in pub.sent[0].message
|
|
notify.evaluate(
|
|
r, _fc(0.40), state, pub, now=NOW
|
|
) # between OFF and ON: stays on, silent
|
|
assert len(pub.sent) == 1
|
|
notify.evaluate(r, _fc(0.20), state, pub, now=NOW)
|
|
assert len(pub.sent) == 2 and "easing" in pub.sent[1].title
|
|
|
|
|
|
def test_heuristic_forecast_ignored(pub):
|
|
state = notify.InMemoryState()
|
|
fc = [
|
|
{
|
|
"station_code": "P.1",
|
|
"horizon_hours": 24,
|
|
"p_warning": 0.9,
|
|
"source": "heuristic",
|
|
}
|
|
]
|
|
notify.evaluate([_reading("P.1", 2.0)], fc, state, pub, now=NOW)
|
|
assert pub.sent == []
|
|
|
|
|
|
def test_stale_feed_and_recovery(pub):
|
|
state = notify.InMemoryState()
|
|
notify.evaluate(
|
|
[_reading("P.1", 1.6, "2026-09-24T12:00:00")], [], state, pub, now=NOW
|
|
)
|
|
assert pub.sent == []
|
|
later = NOW + datetime.timedelta(hours=4)
|
|
notify.evaluate(
|
|
[_reading("P.1", 1.6, "2026-09-24T12:00:00")], [], state, pub, now=later
|
|
)
|
|
assert topics(pub) == ["ping-status"] and "stale" in pub.sent[0].title
|
|
notify.evaluate(
|
|
[_reading("P.1", 1.6, "2026-09-24T12:00:00")],
|
|
[],
|
|
state,
|
|
pub,
|
|
now=later + datetime.timedelta(hours=1),
|
|
)
|
|
assert len(pub.sent) == 1 # still stale, no repeat
|
|
notify.evaluate(
|
|
[_reading("P.1", 1.6, "2026-09-24T17:00:00")],
|
|
[],
|
|
state,
|
|
pub,
|
|
now=later + datetime.timedelta(hours=1),
|
|
)
|
|
assert len(pub.sent) == 2 and "recovered" in pub.sent[1].title
|
|
|
|
|
|
def test_capacity_guard_blocks_stale_threshold(pub):
|
|
"""P.77 2026-09: 3.02 m >= 2.85 m 'warning' at 22 % capacity -> not a flood."""
|
|
state = notify.InMemoryState()
|
|
r = {
|
|
"station_code": "P.77",
|
|
"water_level": 4.40,
|
|
"timestamp": "2026-09-24T12:00:00",
|
|
"discharge_percent": 10.3,
|
|
}
|
|
notify.evaluate([r], [], state, pub, now=NOW)
|
|
assert pub.sent == [] and state.get("level:P.77") is None
|
|
# same level with capacity agreeing -> alert
|
|
r["discharge_percent"] = 82.0
|
|
notify.evaluate([r], [], state, pub, now=NOW)
|
|
assert topics(pub) == ["ping-p77-warning", "ping-warning"]
|
|
|
|
|
|
def test_capacity_guard_exempts_p1_and_missing_pct(pub):
|
|
state = notify.InMemoryState()
|
|
notify.evaluate(
|
|
[
|
|
{
|
|
"station_code": "P.1",
|
|
"water_level": 3.75,
|
|
"timestamp": "2026-09-24T12:00:00",
|
|
"discharge_percent": 40.0,
|
|
}
|
|
],
|
|
[],
|
|
state,
|
|
pub,
|
|
now=NOW,
|
|
)
|
|
assert topics(pub) == ["ping-p1-warning", "ping-warning"]
|
|
pub.sent.clear()
|
|
notify.evaluate(
|
|
[
|
|
{
|
|
"station_code": "P.103",
|
|
"water_level": 6.0,
|
|
"timestamp": "2026-09-24T12:00:00",
|
|
}
|
|
],
|
|
[],
|
|
state,
|
|
pub,
|
|
now=NOW,
|
|
)
|
|
assert topics(pub) == ["ping-p103-warning", "ping-warning"]
|
|
|
|
|
|
def test_capacity_guard_does_not_block_clearing(pub):
|
|
"""Guard applies only to the clear->alert edge; the all-clear always goes out."""
|
|
state = notify.InMemoryState()
|
|
r = {
|
|
"station_code": "P.67",
|
|
"water_level": 2.6,
|
|
"timestamp": "2026-09-24T12:00:00",
|
|
"discharge_percent": 90.0,
|
|
}
|
|
notify.evaluate([r], [], state, pub, now=NOW)
|
|
assert len(pub.sent) == 2
|
|
r.update(water_level=2.2, discharge_percent=30.0)
|
|
notify.evaluate([r], [], state, pub, now=NOW)
|
|
assert "back to normal" in pub.sent[2].title
|
|
|
|
|
|
def test_state_survives_restart_via_sql(tmp_path, pub):
|
|
from sqlalchemy import create_engine
|
|
|
|
eng = create_engine(f"sqlite:///{tmp_path / 'n.db'}")
|
|
state = notify.NotificationState(eng, "sqlite")
|
|
notify.evaluate([_reading("P.1", 3.8)], [], state, pub, now=NOW)
|
|
assert len(pub.sent) == 2
|
|
# "restart": new state object on the same DB, same reading -> nothing re-sent
|
|
state2 = notify.NotificationState(eng, "sqlite")
|
|
notify.evaluate([_reading("P.1", 3.8)], [], state2, pub, now=NOW)
|
|
assert len(pub.sent) == 2
|
|
|
|
|
|
def test_publish_failure_does_not_advance_state():
|
|
"""If ntfy is down the transition must be retried next cycle, not lost."""
|
|
|
|
class Down(notify.NtfyPublisher):
|
|
def __init__(self):
|
|
super().__init__("http://ntfy.test")
|
|
self.calls = 0
|
|
|
|
def publish(self, n):
|
|
self.calls += 1
|
|
return False
|
|
|
|
pub = Down()
|
|
state = notify.InMemoryState()
|
|
notify.evaluate([_reading("P.1", 3.8)], [], state, pub, now=NOW)
|
|
assert pub.calls == 2 and state.get("level:P.1") is None
|
|
# next cycle, ntfy back: the crossing is delivered
|
|
good = FakePublisher()
|
|
notify.evaluate([_reading("P.1", 3.8)], [], state, good, now=NOW)
|
|
assert topics(good) == ["ping-p1-warning", "ping-warning"]
|
|
assert state.get("level:P.1") == "warning"
|