Release God's Eye View as open source

src/data/flowTiles.test.mjs

@@ -0,0 +1,162 @@
+// src/data/flowTiles.test.mjs
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  decodeFlowTile,
+  fetchFlowForBounds,
+  tilesForBounds,
+  getFlowSessionStats,
+  resetFlowTileCache,
+} from './flowTiles.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Real TomTom flow tile, downtown Austin z12 x935 y1686 (probed live 2026-07-16).
+const FIXTURE = path.join(__dirname, 'fixtures', 'tomtom-flow-austin-12-935-1686.pbf');
+const FIXTURE_TILE = { z: 12, x: 935, y: 1686 };
+
+function loadFixture() {
+  return fs.readFileSync(FIXTURE);
+}
+
+// ── decodeFlowTile against the real fixture ─────────────────
+
+test('fixture decode: more than 50 flow segments', () => {
+  const segments = decodeFlowTile(loadFixture(), FIXTURE_TILE.z, FIXTURE_TILE.x, FIXTURE_TILE.y);
+  assert.ok(segments.length > 50, `got ${segments.length}`);
+});
+
+test('fixture decode: every trafficLevel is within [0, 1]', () => {
+  const segments = decodeFlowTile(loadFixture(), FIXTURE_TILE.z, FIXTURE_TILE.x, FIXTURE_TILE.y);
+  for (const s of segments) {
+    assert.ok(Number.isFinite(s.trafficLevel), `non-finite level: ${s.trafficLevel}`);
+    assert.ok(s.trafficLevel >= 0 && s.trafficLevel <= 1, `level out of range: ${s.trafficLevel}`);
+  }
+});
+
+test('fixture decode: all coordinates land in downtown Austin', () => {
+  const segments = decodeFlowTile(loadFixture(), FIXTURE_TILE.z, FIXTURE_TILE.x, FIXTURE_TILE.y);
+  for (const s of segments) {
+    assert.ok(Array.isArray(s.coords) && s.coords.length >= 2, 'polyline too short');
+    for (const [lon, lat] of s.coords) {
+      assert.ok(lon >= -98.0 && lon <= -97.5, `lon out of Austin range: ${lon}`);
+      assert.ok(lat >= 30.0 && lat <= 30.5, `lat out of Austin range: ${lat}`);
+    }
+  }
+});
+
+test('fixture decode: congestion exists (at least one trafficLevel < 1)', () => {
+  const segments = decodeFlowTile(loadFixture(), FIXTURE_TILE.z, FIXTURE_TILE.x, FIXTURE_TILE.y);
+  assert.ok(segments.some((s) => s.trafficLevel < 1), 'no congested segment found');
+});
+
+test('fixture decode: segment shape is {coords, trafficLevel, roadType, closure}', () => {
+  const segments = decodeFlowTile(loadFixture(), FIXTURE_TILE.z, FIXTURE_TILE.x, FIXTURE_TILE.y);
+  for (const s of segments) {
+    assert.equal(typeof s.roadType, 'string');
+    assert.equal(typeof s.closure, 'boolean');
+  }
+  // The fixture carries real closures — closure decoding is exercised, not vacuous.
+  assert.ok(segments.some((s) => s.closure === true), 'expected at least one closure in fixture');
+});
+
+test('decode of a non-MVT buffer returns [] (defensive)', () => {
+  assert.deepEqual(decodeFlowTile(Buffer.from('not a protobuf tile'), 12, 935, 1686), []);
+});
+
+// ── tilesForBounds (re-exported slippy math) ────────────────
+
+test('tilesForBounds: 30.2672,-97.7431 @ z12 -> covers x935 y1686', () => {
+  const tiles = tilesForBounds({
+    south: 30.2672 - 0.001, north: 30.2672 + 0.001,
+    west: -97.7431 - 0.001, east: -97.7431 + 0.001,
+  }, 12);
+  assert.ok(
+    tiles.some((t) => t.z === 12 && t.x === 935 && t.y === 1686),
+    `fixture tile missing: ${JSON.stringify(tiles)}`
+  );
+});
+
+// ── fetchFlowForBounds (stubbed fetch: cache + abort) ───────
+
+/** Bounds fully inside the fixture tile. */
+const FIXTURE_BOUNDS = { south: 30.24, north: 30.26, west: -97.76, east: -97.74 };
+
+function stubFetch(impl) {
+  const original = globalThis.fetch;
+  globalThis.fetch = impl;
+  return () => { globalThis.fetch = original; };
+}
+
+test('fetchFlowForBounds: fetches covering tiles via /api/tomtom and decodes', async () => {
+  resetFlowTileCache();
+  const calls = [];
+  const restore = stubFetch(async (url) => {
+    calls.push(String(url));
+    return new Response(loadFixture(), {
+      status: 200,
+      headers: { 'Content-Type': 'application/x-protobuf' },
+    });
+  });
+  try {
+    const segments = await fetchFlowForBounds(FIXTURE_BOUNDS);
+    assert.equal(calls.length, 1);
+    assert.match(calls[0], /^\/api\/tomtom\/flow\/12\/935\/1686\.pbf$/);
+    assert.ok(segments.length > 50);
+    assert.ok(getFlowSessionStats().tilesFetched >= 1);
+  } finally {
+    restore();
+  }
+});
+
+test('fetchFlowForBounds: decode cache serves repeat calls within TTL (no refetch)', async () => {
+  resetFlowTileCache();
+  let calls = 0;
+  const restore = stubFetch(async () => {
+    calls += 1;
+    return new Response(loadFixture(), { status: 200 });
+  });
+  try {
+    const first = await fetchFlowForBounds(FIXTURE_BOUNDS);
+    const second = await fetchFlowForBounds(FIXTURE_BOUNDS);
+    assert.equal(calls, 1, 'second call must be served from the decode cache');
+    assert.equal(second.length, first.length);
+  } finally {
+    restore();
+  }
+});
+
+test('fetchFlowForBounds: aborted signal rejects (AbortSignal-aware)', async () => {
+  resetFlowTileCache();
+  const restore = stubFetch(async (url, opts) => {
+    // Mimic real fetch abort semantics.
+    if (opts?.signal?.aborted) {
+      const err = new Error('aborted');
+      err.name = 'AbortError';
+      throw err;
+    }
+    return new Response(loadFixture(), { status: 200 });
+  });
+  try {
+    const controller = new AbortController();
+    controller.abort();
+    await assert.rejects(
+      fetchFlowForBounds(FIXTURE_BOUNDS, { signal: controller.signal }),
+      (err) => err.name === 'AbortError'
+    );
+  } finally {
+    restore();
+  }
+});
+
+test('fetchFlowForBounds: non-OK tile responses reject when nothing succeeds', async () => {
+  resetFlowTileCache();
+  const restore = stubFetch(async () => new Response(JSON.stringify({ error: 'no_key' }), { status: 503 }));
+  try {
+    await assert.rejects(fetchFlowForBounds(FIXTURE_BOUNDS));
+  } finally {
+    restore();
+  }
+});