@meri-imperiumi/signalk-passage-briefing 0.2.0

package/tests/webapp.test.js

@@ -0,0 +1,257 @@
+/**
+ * Unit tests for the webapp view models (`public/components/models.mjs`)
+ * that back the custom elements (SPEC §6).
+ *
+ * @file webapp.test.js
+ */
+
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+test("webapp view models", async (t) => {
+  const {
+    COMFORT_TIERS,
+    comfortColor,
+    etaTable,
+    fmtGal,
+    fmtHours,
+    fmtKn,
+    fmtUtc,
+    sailActionCards,
+    sparklineColumns,
+    splitSevere,
+    tacticalNow,
+    hereHourly,
+    hereNow,
+    sailWorkTimeline,
+  } = await import("../public/components/models.mjs");
+
+  await t.test("fmtUtc renders MM-DD HH:MMZ in UTC", () => {
+    assert.equal(fmtUtc("2026-06-21T06:05:00.000Z"), "06-21 06:05Z");
+    assert.equal(fmtUtc(null), "");
+    assert.equal(fmtUtc("not a date"), "");
+  });
+
+  await t.test("fmtHours buckets days, hours and minutes", () => {
+    assert.equal(fmtHours(31.5), "1d 07h");
+    assert.equal(fmtHours(5.34), "5h 20m");
+    assert.equal(fmtHours(0.2), "12m");
+    assert.equal(fmtHours(null), "");
+  });
+
+  await t.test("fmtKn and fmtGal keep one decimal", () => {
+    assert.equal(fmtKn(12.34), "12.3 kn");
+    assert.equal(fmtGal(3.96), "4.0 gal");
+    assert.equal(fmtKn(null), "");
+  });
+
+  await t.test(
+    "sparklineColumns maps comfort tiers and normalizes AWS height",
+    () => {
+      const blocks = [
+        { hoursFromNow: 0, comfortLevel: "champagne", awsKnots: 10 },
+        { hoursFromNow: 1, comfortLevel: "rough", awsKnots: 20 },
+        { hoursFromNow: 2, comfortLevel: "sick", awsKnots: 0 },
+      ];
+      const cols = sparklineColumns(blocks);
+      assert.equal(cols.length, 3);
+      assert.equal(cols[0].heightPct, 50); // 10 of max 20
+      assert.equal(cols[1].heightPct, 100);
+      assert.equal(cols[2].heightPct, 4); // Floor
+      assert.match(cols[0].color, /champagne/);
+      assert.match(cols[2].color, /sick/);
+      assert.ok(cols[1].title.includes("20.0 kn"));
+    },
+  );
+
+  await t.test("sparklineColumns caps the window at 24 columns", () => {
+    const blocks = Array.from({ length: 30 }, (_, i) => ({
+      hoursFromNow: i,
+      comfortLevel: "easy",
+      awsKnots: 10,
+    }));
+    assert.equal(sparklineColumns(blocks).length, 24);
+  });
+
+  await t.test("comfort tiers cover the Sereno scale", () => {
+    assert.deepEqual(
+      COMFORT_TIERS.map((tier) => tier.level),
+      ["champagne", "easy", "coffee", "rough", "sick"],
+    );
+    assert.match(comfortColor("unknown"), /unknown/);
+  });
+
+  await t.test("tacticalNow reads the first block and colors the tier", () => {
+    const exceptions = {
+      next24h: {
+        comfortBlocks: [
+          {
+            hoursFromNow: 0,
+            comfortLevel: "coffee",
+            awsKnots: 14.2,
+            timestamp: "2026-06-21T06:00:00Z",
+          },
+        ],
+      },
+    };
+    const now = tacticalNow(exceptions);
+    assert.equal(now.comfortLevel, "coffee");
+    assert.equal(now.awsKnots, 14.2);
+    assert.equal(now.stamp, "06-21 06:00Z");
+    assert.match(now.color, /coffee/);
+
+    assert.equal(tacticalNow(null).comfortLevel, null);
+    assert.match(tacticalNow(null).color, /unknown/);
+  });
+
+  await t.test("sailActionCards format stamps and night flags", () => {
+    const cards = sailActionCards({
+      next24h: {
+        sailChanges: [
+          {
+            hoursFromNow: 6,
+            timestamp: "2026-06-21T12:00:00Z",
+            sailState: "GENOA_1_MAIN",
+            night: false,
+          },
+          {
+            hoursFromNow: 18,
+            timestamp: "2026-06-22T00:00:00Z",
+            sailState: "STAYSAIL_MAIN_1_REEF",
+            night: true,
+          },
+        ],
+      },
+    });
+    assert.equal(cards[0].stamp, "06-21 12:00Z");
+    assert.equal(cards[1].night, true);
+    assert.equal(cards[1].sailState, "STAYSAIL_MAIN_1_REEF");
+    assert.deepEqual(sailActionCards(null), []);
+  });
+
+  await t.test("splitSevere tokenizes severe keywords", () => {
+    const tokens = splitSevere(
+      "EXPECT WINDS 35 KNOTS. Rough seas with heavy GALE warnings.",
+    );
+    const severeWords = tokens
+      .filter((t) => t.severe)
+      .map((t) => t.text.toUpperCase());
+    assert.deepEqual(severeWords, ["ROUGH SEAS", "GALE"]);
+    assert.ok(tokens.some((t) => !t.severe && t.text.includes("EXPECT")));
+    // Reconstructing the tokens reproduces the input exactly
+    const input = "EXPECT WINDS 35 KNOTS. Rough seas with heavy GALE warnings.";
+    assert.equal(
+      splitSevere(input)
+        .map((t) => t.text)
+        .join(""),
+      input,
+    );
+    assert.deepEqual(splitSevere("plain text only"), [
+      { text: "plain text only", severe: false },
+    ]);
+    assert.deepEqual(splitSevere(null), []);
+  });
+
+  await t.test("hereHourly evaluates comfort at SOG 0 over 24h", () => {
+    const payload = {
+      metadata: { fetchedAt: "2026-09-27T10:00:00.000Z", mode: "here" },
+      waypoints: [
+        {
+          lat: -21.1,
+          lon: -175.2,
+          forecasts: Array.from({ length: 40 }, (_, i) => ({
+            timestamp: new Date(
+              new Date("2026-09-27T00:00:00.000Z").getTime() + i * 3600000,
+            ).toISOString(),
+            surface: { tws: 12, twd: 45, mslp: 1013, gust: 18 },
+            marine: {
+              hsCombined: 1.2,
+              tpCombined: 7,
+              dirCombined: 160,
+            },
+            current: { drift: 1, set: 45 },
+          })),
+        },
+      ],
+    };
+    const rows = hereHourly(payload, { waterline_length_m: 9.4 });
+    assert.equal(rows.length, 24, "24 hourly rows from fetchedAt");
+    assert.equal(rows[0].hoursFromNow, 0);
+    assert.equal(rows[0].sogKnots, 0);
+    // At SOG 0 AWS equals TWS
+    assert.equal(rows[0].awsKnots, 12);
+    assert.ok(typeof rows[0].azMs2 === "number");
+    assert.ok(typeof rows[0].comfortLevel === "string");
+    assert.ok(typeof rows[0].night === "boolean");
+
+    const now = hereNow(payload, rows);
+    assert.equal(now.twsKnots, 12);
+    assert.equal(now.gustKnots, 18);
+    assert.equal(now.hsMeters, 1.2);
+    assert.equal(now.currentDriftKnots, 1);
+    assert.equal(now.mslpHpa, 1013);
+    assert.equal(now.mslpTrend, 0);
+    assert.equal(now.comfortLevel, rows[0].comfortLevel);
+  });
+
+  await t.test("hereNow and hereHourly handle empty payloads", () => {
+    assert.deepEqual(hereHourly(null), []);
+    const now = hereNow(null);
+    assert.equal(now.comfortLevel, null);
+    assert.equal(now.twsKnots, null);
+    assert.equal(now.stamp, "");
+  });
+
+  await t.test("etaTable builds percentile rows and motor totals", () => {
+    const table = etaTable({
+      passageSummary: {
+        etaP10: "2026-06-22T12:00:00Z",
+        etaP50: "2026-06-22T13:00:00Z",
+        etaP90: "2026-06-22T14:30:00Z",
+        totalMotorHours: 40,
+        totalFuelGal: 32,
+      },
+    });
+    assert.deepEqual(
+      table.rows.map((row) => row.label),
+      ["P10", "P50", "P90"],
+    );
+    assert.equal(table.rows[2].stamp, "06-22 14:30Z");
+    assert.equal(table.motorHours, "1d 16h");
+    assert.equal(table.fuel, "32.0 gal");
+    assert.equal(etaTable(null).motorHours, "");
+  });
+
+  await t.test(
+    "sailWorkTimeline labels maneuvers and keeps changes plain",
+    () => {
+      const timeline = sailWorkTimeline({
+        passageSummary: {
+          sailChanges: [
+            {
+              hoursFromNow: 2,
+              timestamp: "2026-06-21T08:00:00.000Z",
+              sailState: "MAIN_REEF_1",
+            },
+            {
+              hoursFromNow: 4,
+              timestamp: "2026-06-21T10:00:00.000Z",
+              sailState: "MAIN_FULL@port",
+              maneuver: "tack",
+              toTack: "port",
+              distanceFromStartNm: 32.4,
+              twsAtManeuver: 12.2,
+            },
+          ],
+        },
+      });
+      assert.equal(timeline.length, 2);
+      assert.equal(timeline[0].label, "MAIN_REEF_1");
+      assert.equal(timeline[0].detail, "");
+      assert.equal(timeline[1].label, "Tack to port");
+      assert.equal(timeline[1].detail, "32 nm · 12.2 kn");
+      assert.equal(timeline[1].stamp, "06-21 10:00Z");
+      assert.deepEqual(sailWorkTimeline(null), []);
+    },
+  );
+});

package/tests/zone-source.test.js

@@ -0,0 +1,226 @@
+/**
+ * Unit tests for GMDSS zone resolution and bulletin sources (work
+ * doc #9): position/track fixtures → zone arrays, boundary
+ * straddling, antimeridian routes, roman numerals, GMDSS HTML `<pre>`
+ * extraction, TGFTP URL construction and the fetch ladder ordering.
+ *
+ * @file zone-source.test.js
+ */
+
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const {
+  extractGmdssPre,
+  fetchZoneBulletins,
+  gmdssBulletinUrl,
+  navtexStation,
+  parseUkhoWarnings,
+  resolveZones,
+  romanNumeral,
+  tgftpUrl,
+  ukhoWarningsUrl,
+} = require("../plugin/zone-source.js");
+
+test("parseUkhoWarnings: canonical keys, tolerant fallbacks, unknown payload", () => {
+  const parsed = parseUkhoWarnings({
+    warnings: [
+      {
+        text: "CHART DAMAGE",
+        issuedAt: "2026-09-27T10:00:00Z",
+        coordinates: [
+          [-21.1, 175.2],
+          [-21.5, 175.8],
+          [-21.2, 176.1],
+        ],
+      },
+      {
+        message: "DRIFTING CONTAINER",
+        created: "not-a-date",
+        positions: [[10, 20]],
+      },
+      { text: "" },
+      null,
+    ],
+  });
+  assert.equal(parsed.length, 2);
+  assert.equal(parsed[0].text, "CHART DAMAGE");
+  assert.equal(parsed[0].issuedAt, "2026-09-27T10:00:00.000Z");
+  assert.deepEqual(parsed[0].coordinates, [
+    [175.2, -21.1],
+    [175.8, -21.5],
+    [176.1, -21.2],
+  ]);
+  assert.equal(parsed[1].text, "DRIFTING CONTAINER");
+  assert.equal(parsed[1].issuedAt, null);
+  assert.deepEqual(parsed[1].coordinates, [[20, 10]]);
+  assert.deepEqual(parseUkhoWarnings({ nope: true }), []);
+  assert.deepEqual(parseUkhoWarnings(null), []);
+});
+
+test("zone resolution: Tonga position resolves to XIV", () => {
+  assert.deepEqual(resolveZones([[-175.2, -21.1]]), [14]);
+  assert.deepEqual(resolveZones([[174.3, -35.3]]), [14]); // Opua, NZ
+});
+
+test("zone resolution: boundary crossing straddles X and XIV", () => {
+  // The X/XIV boundary sits at 160E: a route from the Tasman into
+  // Fijian waters legitimately activates both zones
+  const zones = resolveZones([
+    [155, -40],
+    [165, -38],
+  ]);
+  assert.deepEqual(zones, [10, 14]);
+});
+
+test("zone resolution: antimeridian route stays in XIV", () => {
+  const zones = resolveZones([
+    [-179, -25],
+    [179, -30],
+  ]);
+  assert.deepEqual(zones, [14]);
+});
+
+test("zone resolution: outside all bundled zones yields nothing", () => {
+  // Arctic latitudes: the polar NAVAREAs are not in the bundled file
+  assert.deepEqual(resolveZones([[0, 78]]), []);
+  // London resolves to zone I (UK / North Atlantic, 48-75N)
+  assert.deepEqual(resolveZones([[0, 51.5]]), [1]);
+});
+
+test("zone resolution: overlapping zones prefer the most specific", () => {
+  // 20N 50E sits in both VIII (to 30N) and IX (12-30N); the smaller
+  // polygon (IX, the Arabian Sea zone) wins for a single point
+  assert.deepEqual(resolveZones([[50, 20]]), [9]);
+});
+
+// --- URLs & naming ----------------------------------------------------------
+
+test("roman numerals and URL construction", () => {
+  assert.equal(romanNumeral(14), "XIV");
+  assert.equal(romanNumeral(10), "X");
+  assert.equal(romanNumeral(4), "IV");
+  assert.equal(romanNumeral(21), "XXI");
+  assert.equal(gmdssBulletinUrl(14), "https://weather.gmdss.org/XIV.html");
+  assert.equal(
+    ukhoWarningsUrl(14),
+    "https://msi.admiralty.co.uk/api/Warnings/Area/XIV",
+  );
+  assert.equal(
+    tgftpUrl("fqps01", "NFFN"),
+    "https://tgftp.nws.noaa.gov/data/raw/fq/fqps01.nffn..txt",
+  );
+  assert.equal(navtexStation(14), "Z"); // Wellington
+  assert.equal(navtexStation(10), "O"); // Sydney
+});
+
+// --- GMDSS HTML extraction ------------------------------------------------------
+
+test("extractGmdssPre pulls the bulletin body with entities decoded", () => {
+  const html = `<!doctype html><html><head><title>XIV</title></head>
+    <body><h1>NAVAREA XIV</h1>
+    <pre>ZCZC GA14
+011200Z AUG 26
+GALE WARNING &amp; ROUGH SEAS
+NNNN</pre>
+    <footer>chrome</footer></body></html>`;
+  const text = extractGmdssPre(html);
+  assert.match(text, /^ZCZC GA14/);
+  assert.match(text, /GALE WARNING & ROUGH SEAS\nNNNN$/);
+  assert.equal(extractGmdssPre("<html><body>no pre</body></html>"), null);
+});
+
+// --- Fetch ladder ------------------------------------------------------------
+
+function mockFetch(handlers) {
+  return async (url) => {
+    for (const [pattern, response] of Object.entries(handlers)) {
+      if (String(url).includes(pattern)) {
+        if (response instanceof Error) {
+          throw response;
+        }
+        return response(url);
+      }
+    }
+    throw new Error(`unexpected url ${url}`);
+  };
+}
+
+test("fetch ladder: TGFTP preferred when configured, portal fallback", async () => {
+  const calls = [];
+  const tgftpResponse = (url) => {
+    calls.push(`tgftp:${url}`);
+    return {
+      ok: true,
+      text: async () => "FQPS01 NFFN 011200Z AUG 26\nGALE WARNING\nNNNN",
+    };
+  };
+
+  // Station configured: TGFTP answers, portal never called
+  let entries = await fetchZoneBulletins({
+    zones: [14],
+    tgftpStations: [{ zone: 14, header: "fqps01", station: "NFFN" }],
+    fetchImpl: mockFetch({
+      "tgftp.nws.noaa.gov": tgftpResponse,
+      "weather.gmdss.org": (url) => {
+        calls.push(`gmdss:${url}`);
+        throw new Error("should not be called");
+      },
+    }),
+  });
+  assert.equal(entries.length, 1);
+  assert.equal(entries[0].source, "api");
+  assert.match(entries[0].text, /GALE WARNING/);
+  assert.equal(
+    calls.some((c) => c.startsWith("tgftp:")),
+    true,
+  );
+  assert.equal(
+    calls.some((c) => c.startsWith("gmdss:")),
+    false,
+  );
+
+  // TGFTP down: the portal takes over
+  calls.length = 0;
+  entries = await fetchZoneBulletins({
+    zones: [14],
+    tgftpStations: [{ zone: 14, header: "fqps01", station: "NFFN" }],
+    fetchImpl: mockFetch({
+      "tgftp.nws.noaa.gov": new Error("connection refused"),
+      "weather.gmdss.org": (url) => {
+        calls.push(`gmdss:${url}`);
+        return {
+          ok: true,
+          text: async () =>
+            "<html><pre>ZCZC GA14 011200Z AUG 26 NAVAREA XIV 114/26 GALE WARNING</pre></html>",
+        };
+      },
+    }),
+  });
+  assert.equal(entries.length, 1);
+  assert.match(entries[0].text, /GALE WARNING/);
+  assert.equal(
+    calls.some((c) => c.startsWith("gmdss:")),
+    true,
+  );
+});
+
+test("fetch ladder: only resolved zones are fetched", async () => {
+  const fetched = [];
+  await fetchZoneBulletins({
+    zones: [10, 14],
+    fetchImpl: mockFetch({
+      "weather.gmdss.org": (url) => {
+        fetched.push(String(url));
+        return {
+          ok: true,
+          text: async () => "<html><pre>SYNOPSIS</pre></html>",
+        };
+      },
+    }),
+  });
+  // XIV and X fetched; the other nineteen zones untouched
+  assert.equal(fetched.length, 2);
+  assert.ok(fetched.some((u) => u.includes("XIV.html")));
+  assert.ok(fetched.some((u) => u.includes("X.html")));
+});