Fire heat intensity
@@ -1942,7 +1951,8 @@ let acGroup = null, acOn = true, acMilOn = false, acMilSupported = false;
let trainsGroup = null, trainsOn = true;
let vesselsGroup = null, vesselsOn = false;
let stormsGroup = null, stormsOn = true;
-let overlayReq = {ac:0, trains:0, vessels:0, alerts:0, perim:0, incidents:0, storms:0, sar:0};
+let conflictsGroup = null, conflictsOn = false, conflictsCache = null;
+let overlayReq = {ac:0, trains:0, vessels:0, alerts:0, perim:0, incidents:0, storms:0, sar:0, conflicts:0};
let moveDebounce = null;
let overlayAbort = null;
let lastCell = '';
@@ -2210,8 +2220,10 @@ async function initMap() {
trainsOn = document.getElementById('lp-trains-on').checked;
vesselsOn = document.getElementById('lp-vessels-on').checked;
stormsOn = document.getElementById('lp-storms-on').checked;
+ conflictsOn = document.getElementById('lp-conflicts-on').checked;
connectLiveWs();
loadChokepoints();
+ probeConflicts();
requestAnimationFrame(() => {
if (firesOn) loadFires();
setTimeout(() => {
@@ -3484,6 +3496,96 @@ async function loadStorms() {
}
}
+function conflictSeverityColor(sev) {
+ const s = String(sev || '').toLowerCase();
+ if (s === 'war') return '#ff2a6d';
+ if (s === 'high') return '#fb923c';
+ if (s === 'elevated') return '#facc15';
+ return '#35e0ff';
+}
+function hideConflictsToggle() {
+ const row = document.getElementById('conflicts-layer');
+ if (row) row.hidden = true;
+ const cb = document.getElementById('lp-conflicts-on');
+ if (cb) cb.checked = false;
+ conflictsOn = false;
+ conflictsCache = null;
+ conflictsGroup = dropLayer(conflictsGroup);
+}
+function paintConflicts() {
+ if (!map || !conflictsOn) return;
+ const zones = (conflictsCache && Array.isArray(conflictsCache.zones)) ? conflictsCache.zones : [];
+ conflictsGroup = dropLayer(conflictsGroup);
+ const markers = [];
+ for (const z of zones) {
+ if (z.lat == null || z.lon == null) continue;
+ const lat = Number(z.lat), lon = Number(z.lon);
+ if (!Number.isFinite(lat) || !Number.isFinite(lon)) continue;
+ const col = conflictSeverityColor(z.severity);
+ const sev = String(z.severity || '').toLowerCase();
+ const radius = sev === 'war' ? 10 : sev === 'high' ? 8 : 7;
+ const m = L.circleMarker([lat, lon], {
+ radius,
+ color: col,
+ fillColor: col,
+ fillOpacity: 0.28,
+ weight: 2,
+ className: 'conflict-zone',
+ });
+ const n = Number(z.eventCount);
+ const count = Number.isFinite(n) ? n : 0;
+ m.bindPopup(
+ `
` +
+ `
${esc(z.severity || '')} · ${esc(count)} events
` +
+ `
${esc(z.label || '')}` +
+ `
${esc(z.description || '')}
` +
+ `
`
+ );
+ markers.push(m);
+ }
+ conflictsGroup = L.layerGroup(markers).addTo(map);
+ const countEl = document.getElementById('lp-conflicts-count');
+ if (countEl) countEl.textContent = markers.length.toLocaleString();
+ addExtraAttrib('Curated OSINT conflict catalog');
+}
+async function probeConflicts() {
+ await loadConflicts(false);
+}
+async function toggleConflicts() {
+ const cb = document.getElementById('lp-conflicts-on');
+ conflictsOn = !!(cb && cb.checked);
+ if (conflictsOn) await loadConflicts(true);
+ else conflictsGroup = dropLayer(conflictsGroup);
+}
+async function loadConflicts(paint) {
+ const shouldPaint = paint === true || conflictsOn;
+ const req = ++overlayReq.conflicts;
+ const countEl = document.getElementById('lp-conflicts-count');
+ try {
+ if (!conflictsCache) {
+ // Own fetch — catalog is viewport-independent; overlayAbort on
+ // moveend must not cancel this (and we never refetch on pan).
+ const r = await fetch(`${API}/api/conflicts`);
+ if (req !== overlayReq.conflicts) return;
+ if (r.status === 404) {
+ hideConflictsToggle();
+ return;
+ }
+ if (!r.ok) throw new Error('conflicts ' + r.status);
+ const body = await r.json();
+ if (req !== overlayReq.conflicts) return;
+ conflictsCache = body && typeof body === 'object' ? body : { zones: [] };
+ }
+ const zones = Array.isArray(conflictsCache.zones) ? conflictsCache.zones : [];
+ if (countEl) countEl.textContent = zones.length.toLocaleString();
+ if (shouldPaint) paintConflicts();
+ } catch (e) {
+ if (req !== overlayReq.conflicts) return;
+ console.error('Conflicts load failed', e);
+ if (countEl) countEl.textContent = 'err';
+ }
+}
+
/* ═══════════════ INITIAL LOAD ═══════════════ */
initNav();
initSettings();
diff --git a/tests/test_api_stats.py b/tests/test_api_stats.py
new file mode 100644
index 0000000..870965d
--- /dev/null
+++ b/tests/test_api_stats.py
@@ -0,0 +1,87 @@
+"""GET /api/stats HUD counter contract (counts only, small, never 500)."""
+
+from __future__ import annotations
+
+import asyncio
+import re
+from datetime import timezone
+
+import httpx
+
+from main import app, _stats_counts
+
+BASE = "http://test"
+
+EXPECTED_KEYS = ("aircraft", "vessels", "trains", "cameras",
+ "fires", "quakes", "alerts", "timestamp")
+
+
+async def _get(path: str) -> httpx.Response:
+ transport = httpx.ASGITransport(app=app)
+ async with httpx.AsyncClient(transport=transport, base_url=BASE) as client:
+ return await client.get(path)
+
+
+def test_stats_200_all_keys_present():
+ resp = asyncio.run(_get("/api/stats"))
+ assert resp.status_code == 200
+ body = resp.json()
+ for key in EXPECTED_KEYS:
+ assert key in body, f"missing key {key}"
+ assert "max-age" in (resp.headers.get("cache-control") or "").lower()
+
+
+def test_stats_counters_are_ints():
+ body = asyncio.run(_get("/api/stats")).json()
+ for key in EXPECTED_KEYS:
+ if key == "timestamp":
+ continue
+ assert isinstance(body[key], int), f"{key} is not an int: {body[key]!r}"
+
+
+def test_stats_timestamp_is_iso8601_z():
+ body = asyncio.run(_get("/api/stats")).json()
+ ts = body["timestamp"]
+ # ISO8601 with a trailing Z (we normalize +00:00 -> Z).
+ assert isinstance(ts, str) and ts.endswith("Z")
+ assert re.match(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}", ts)
+
+
+def test_stats_payload_is_tiny():
+ resp = asyncio.run(_get("/api/stats"))
+ assert len(resp.content) < 2048, "stats payload must be counts-only, not GeoJSON"
+
+
+def test_stats_counts_reflect_last_known(monkeypatch):
+ """aircraft/vessels/trains/alerts come from in-memory last-known state."""
+ import live_layers
+
+ monkeypatch.setattr(live_layers, "aircraft_last_known", {str(i): {} for i in range(7)})
+ monkeypatch.setattr(live_layers, "vessel_last_known", {str(i): {} for i in range(3)})
+ monkeypatch.setattr(live_layers, "train_count", 11)
+ monkeypatch.setattr(live_layers, "nws_alert_count", 5)
+
+ # _stats_counts imports the dicts/counters inside the function from live_layers,
+ # so monkeypatching the module attributes is what it observes.
+ from main import _stats_counts as fn
+
+ body = asyncio.run(fn())
+ assert body["aircraft"] == 7
+ assert body["vessels"] == 3
+ assert body["trains"] == 11
+ assert body["alerts"] == 5
+
+
+def test_stats_db_failure_degrades_to_zero(monkeypatch):
+ """A down DB yields zeros for the SQL-backed counters, never a 500."""
+ # Make the session factory raise synchronously so the try/except in
+ # _stats_counts degrades the SQL counters to zero (no dangling coroutine).
+ def _raise(*args, **kwargs):
+ raise RuntimeError("db down")
+
+ monkeypatch.setattr("main.async_session", _raise)
+ body = asyncio.run(_stats_counts())
+ assert body["cameras"] == 0
+ assert body["fires"] == 0
+ assert body["quakes"] == 0
+ assert isinstance(body["timestamp"], str)
\ No newline at end of file
diff --git a/tests/test_conflicts_frontend.py b/tests/test_conflicts_frontend.py
new file mode 100644
index 0000000..058fd3b
--- /dev/null
+++ b/tests/test_conflicts_frontend.py
@@ -0,0 +1,66 @@
+"""Conflicts Leaflet overlay: default-off toggle, catalog fetch, no jitter."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+HTML = (ROOT / "app/static/index.html").read_text()
+
+
+def _fn(name: str, until: str | None = None) -> str:
+ chunk = HTML.split(f"function {name}", 1)[1]
+ if until:
+ chunk = chunk.split(until, 1)[0]
+ return chunk
+
+
+def test_conflicts_toggle_default_off():
+ assert 'id="lp-conflicts-on"' in HTML
+ assert 'id="conflicts-layer"' in HTML
+ assert "> Conflicts<" in HTML or "> Conflicts", 1)[0]
+ assert "checked" not in on
+
+
+def test_conflicts_fetches_catalog_not_liveuamap():
+ js = _fn("loadConflicts", "/* ═══════════════ INITIAL LOAD")
+ assert "/api/conflicts" in js
+ assert "liveuamap.com" not in HTML.lower()
+ assert "Math.random" not in js
+ assert "jitter" not in js.lower()
+
+
+def test_conflicts_not_refetched_on_moveend():
+ refresh = HTML.split("function refreshLiveOverlays", 1)[1].split(
+ "function addExtraAttrib", 1
+ )[0]
+ assert "loadConflicts" not in refresh
+ assert "probeConflicts" not in refresh
+ init = HTML.split("function initMap", 1)[1].split("function readMapPrefs", 1)[0]
+ assert "probeConflicts()" in init
+ assert "loadConflicts(true)" not in init
+ assert "paintConflicts()" not in init
+
+
+def test_conflicts_hides_toggle_on_404():
+ js = _fn("loadConflicts", "/* ═══════════════ INITIAL LOAD")
+ assert "r.status === 404" in js
+ assert "hideConflictsToggle()" in js
+ hide = _fn("hideConflictsToggle", "function paintConflicts")
+ assert "row.hidden = true" in hide
+ assert "lp-conflicts-on" in hide
+
+
+def test_conflicts_popup_and_severity_colors():
+ paint = _fn("paintConflicts", "async function probeConflicts")
+ assert "z.label" in paint
+ assert "z.description" in paint
+ assert "eventCount" in paint
+ assert "L.circleMarker" in paint
+ assert "z.lat == null || z.lon == null" in paint
+ assert "Number.isFinite(lat)" in paint
+ color = _fn("conflictSeverityColor", "function hideConflictsToggle")
+ assert "war" in color and "#ff2a6d" in color
+ assert "high" in color and "#fb923c" in color
+ assert "elevated" in color and "#facc15" in color
diff --git a/tests/test_infrastructure.py b/tests/test_infrastructure.py
new file mode 100644
index 0000000..27dd80f
--- /dev/null
+++ b/tests/test_infrastructure.py
@@ -0,0 +1,145 @@
+"""GET /api/infrastructure — Overpass nuclear markers."""
+
+import asyncio
+
+import httpx
+
+from live_layers import (
+ normalize_infra_element,
+ overlay_catalog,
+ overpass_nuclear_to_markers,
+ _cache,
+)
+from main import app
+
+BASE = "http://test"
+
+OVERPASS = {
+ "version": 0.6,
+ "generator": "Overpass API",
+ "elements": [
+ {
+ "type": "node",
+ "id": 12345,
+ "lat": 44.0,
+ "lon": -1.5,
+ "tags": {"name": "Test NPP", "operator": "EDF", "plant:source": "nuclear"},
+ },
+ {
+ "type": "way",
+ "id": 67890,
+ "center": {"lat": 43.5, "lon": -1.25},
+ "tags": {"name": "Test Plant Way", "plant:source": "nuclear"},
+ },
+ {
+ "type": "relation",
+ "id": 999,
+ "center": {"lat": 43.0, "lon": -1.0},
+ "tags": {},
+ },
+ ],
+}
+
+
+async def _get(path: str) -> httpx.Response:
+ transport = httpx.ASGITransport(app=app)
+ async with httpx.AsyncClient(transport=transport, base_url=BASE) as client:
+ return await client.get(path)
+
+
+def test_normalize_node_to_marker():
+ m = normalize_infra_element(OVERPASS["elements"][0], "nuclear")
+ assert m["id"] == "node/12345"
+ assert m["name"] == "Test NPP"
+ assert m["lat"] == 44.0
+ assert m["lon"] == -1.5
+ assert m["type"] == "nuclear"
+ assert m["extra"]["operator"] == "EDF"
+ assert "name" not in m["extra"]
+
+
+def test_way_center_and_unnamed_fallback():
+ way = normalize_infra_element(OVERPASS["elements"][1], "nuclear")
+ assert way["lat"] == 43.5
+ assert way["lon"] == -1.25
+ rel = normalize_infra_element(OVERPASS["elements"][2], "nuclear")
+ assert rel["name"] == "relation/999"
+
+
+def test_overpass_json_to_markers():
+ markers = overpass_nuclear_to_markers(OVERPASS)
+ assert len(markers) == 3
+ assert markers[0]["id"] == "node/12345"
+
+
+def test_missing_bbox_400():
+ resp = asyncio.run(_get("/api/infrastructure?types=nuclear"))
+ assert resp.status_code == 400
+
+
+def test_unknown_type_422():
+ resp = asyncio.run(_get("/api/infrastructure?types=military&bbox=-2,43,-1,44"))
+ assert resp.status_code == 422
+
+
+def test_map_infrastructure_returns_markers(monkeypatch):
+ async def fake_fetch(types, bbox):
+ return [
+ {"id": "node/1", "name": "X", "lat": 1.0, "lon": 2.0,
+ "type": "nuclear", "extra": {}}
+ ]
+
+ monkeypatch.setattr("main.fetch_infrastructure", fake_fetch)
+ resp = asyncio.run(_get("/api/infrastructure?types=nuclear&bbox=-2,43,-1,44"))
+ assert resp.status_code == 200
+ body = resp.json()
+ assert body[0]["name"] == "X"
+ assert body[0]["type"] == "nuclear"
+ assert "max-age" in (resp.headers.get("cache-control") or "").lower()
+
+
+def test_overlay_catalog_has_infra_nuclear():
+ entry = overlay_catalog()["infra_nuclear"]
+ assert entry["kind"] == "points"
+ assert "nuclear" in entry["endpoint"]
+
+
+def test_fetch_infrastructure_cache_hit_no_refetch(monkeypatch):
+ _cache.clear()
+ hits = {"n": 0}
+
+ class FakeResp:
+ def raise_for_status(self):
+ pass
+
+ def json(self):
+ return OVERPASS
+
+ class FakeClient:
+ def __init__(self, **kw):
+ pass
+
+ async def __aenter__(self):
+ return self
+
+ async def __aexit__(self, *exc):
+ return False
+
+ async def post(self, url, data=None, timeout=None):
+ hits["n"] += 1
+ assert "overpass-api.de" in url
+ assert "plant:source" in data["data"]
+ assert "nuclear" in data["data"]
+ return FakeResp()
+
+ monkeypatch.setattr("live_layers.httpx.AsyncClient", FakeClient)
+ monkeypatch.setattr("live_layers._http", None)
+
+ from live_layers import fetch_infrastructure
+
+ m1 = asyncio.run(fetch_infrastructure("nuclear", "-2,43,-1,44"))
+ m2 = asyncio.run(fetch_infrastructure("nuclear", "-2,43,-1,44"))
+ assert len(m1) == 3
+ assert m2 == m1
+ assert hits["n"] == 1
+ _cache.clear()
diff --git a/tests/test_live_layers.py b/tests/test_live_layers.py
index a646deb..9b31f71 100644
--- a/tests/test_live_layers.py
+++ b/tests/test_live_layers.py
@@ -27,7 +27,7 @@ from live_layers import (
_wfigs_params,
)
-from camera_scraper import parse_caltrans_json, parse_mdot_json
+from camera_scraper import parse_caltrans_json, parse_udot_ibi_page, parse_odot_json, parse_mdot_json
def test_parse_bbox_and_radius_clamps_to_150_nm():
@@ -259,6 +259,127 @@ def test_parse_caltrans_skips_oos_and_maps_jpeg_hls():
assert "rtsp://" not in cam["snapshot_url"].lower()
+# ── UDOT IBI 511 parser ──────────────────────────────────────────────────
+
+def _udot_row(cam_id, lng, lat, **img_overrides):
+ img = {
+ "id": cam_id, "cameraSiteId": cam_id,
+ "imageUrl": f"/map/Cctv/{cam_id}", "disabled": False, "blocked": False,
+ }
+ img.update(img_overrides)
+ return {
+ "id": cam_id, "sourceId": "102771", "source": "ADX",
+ "roadway": "Unknown", "direction": "Unknown",
+ "location": "Freedom Blvd / 200 W @ 1100 N, PVO",
+ "latLng": {"geography": {
+ "coordinateSystemId": 4326,
+ "wellKnownText": f"POINT ({lng} {lat})"}},
+ "images": [img],
+ }
+
+
+def _udot_page(rows):
+ import json
+ return json.dumps({"draw": 0, "recordsTotal": len(rows),
+ "recordsFiltered": len(rows), "data": rows})
+
+
+def test_parse_udot_wkt_maps_lng_lat():
+ cams = parse_udot_ibi_page(_udot_page([_udot_row(112731, -111.66204, 40.24863)]))
+ assert len(cams) == 1
+ cam = cams[0]
+ # WKT is `POINT (lng lat)` — order must not be swapped.
+ assert cam["location_lat"] == 40.24863
+ assert cam["location_lon"] == -111.66204
+ assert cam["discovery_source"] == "udot"
+ assert cam["vendor"] == "UDOT"
+ assert cam["source_url"] == "https://prod-ut.ibi511.com/map/Cctv/112731"
+ assert cam["snapshot_url"] == cam["source_url"]
+ assert "rtsp://" not in cam["source_url"].lower()
+ assert cam["raw"]["udot_id"] == 112731
+
+
+def test_parse_udot_skips_blocked_and_disabled():
+ rows = [
+ _udot_row(1, -111.0, 40.0),
+ _udot_row(2, -111.1, 40.1, blocked=True),
+ _udot_row(3, -111.2, 40.2, disabled=True),
+ ]
+ rows.append(_udot_row(4, -111.3, 40.3))
+ rows[3]["images"] = [] # no images → drop
+ cams = parse_udot_ibi_page(_udot_page(rows))
+ assert [c["raw"]["udot_id"] for c in cams] == [1]
+
+
+def test_parse_udot_drops_out_of_bbox():
+ rows = [
+ _udot_row(1, -111.0, 40.0), # inside Utah
+ _udot_row(2, -100.0, 40.0), # east of -108.9
+ _udot_row(3, -120.0, 40.0), # west of -114.2
+ _udot_row(4, -111.0, 44.0), # north of 42.1
+ _udot_row(5, -111.0, 30.0), # south of 36.9
+ ]
+ cams = parse_udot_ibi_page(_udot_page(rows))
+ assert [c["raw"]["udot_id"] for c in cams] == [1]
+
+
+def test_parse_udot_bad_payload_returns_empty():
+ import json
+ assert parse_udot_ibi_page("not json") == []
+ assert parse_udot_ibi_page(json.dumps({"data": None})) == []
+ assert parse_udot_ibi_page(json.dumps({"data": "nope"})) == []
+
+
+def test_parse_udot_missing_wkt_skipped():
+ row = _udot_row(1, -111.0, 40.0)
+ row["latLng"] = {}
+ assert parse_udot_ibi_page(_udot_page([row])) == []
+
+
+def test_parse_odot_tripcheck_keeps_valid_skips_missing_and_oob():
+ payload = """
+ {"features":[
+ {"attributes":{
+ "cameraId":277,"filename":"AstoriaUS101_pid392.jpg",
+ "latitude":46.18785,"longitude":-123.85347,
+ "route":"US101 ","title":"US101 at Astoria"
+ }},
+ {"attributes":{
+ "cameraId":200,"filename":"","latitude":45.0,"longitude":-122.0,
+ "route":"I-5","title":"missing filename"
+ }},
+ {"attributes":{
+ "cameraId":300,"filename":"nocal_pid1.jpg",
+ "latitude":40.0,"longitude":-122.0,
+ "route":"US97","title":"out of bbox"
+ }},
+ {"attributes":{
+ "cameraId":400,"filename":"badcoord_pid2.jpg",
+ "latitude":null,"longitude":-122.0,
+ "route":"OR22","title":"null coord"
+ }}
+ ]}
+ """
+ cams = parse_odot_json(payload, "www.tripcheck.com")
+ assert len(cams) == 1
+ cam = cams[0]
+ assert cam["discovery_source"] == "odot"
+ assert cam["snapshot_url"] == (
+ "https://tripcheck.com/RoadCams/cams/AstoriaUS101_pid392.jpg")
+ assert cam["source_url"] == cam["snapshot_url"]
+ assert cam["location_lat"] == 46.18785
+ assert cam["location_lon"] == -123.85347
+ assert "US101 at Astoria" in cam["location_name"]
+ assert cam["vendor"] == "ODOT"
+ assert cam["device_type"] == "http"
+ assert "rtsp://" not in cam["snapshot_url"].lower()
+
+
+def test_parse_odot_tripcheck_handles_malformed():
+ assert parse_odot_json("not json", "www.tripcheck.com") == []
+ assert parse_odot_json('{"features":null}', "www.tripcheck.com") == []
+
+
def test_parse_mdot_extracts_html_fields_and_bbox_filters():
rows = [
# In-bbox, full fields.