@vatvaghool/create-ipl-dashboard 0.1.18 → 0.1.23

package/template/tests/dashboard-polling.test.ts

@@ -1,96 +0,0 @@
-import assert from "node:assert/strict";
-import { afterEach, describe, it, mock } from "node:test";
-import type { DashboardData } from "../app/types.ts";
-import {
-  createDashboardPoller,
-  DASHBOARD_POLL_INTERVAL_MS,
-} from "../app/hooks/dashboardPolling.ts";
-
-const flushPromises = () => new Promise<void>((resolve) => queueMicrotask(resolve));
-
-const createResponse = (data: DashboardData) =>
-  ({
-    ok: true,
-    status: 200,
-    json: async () => data,
-  }) as Response;
-
-describe("dashboard polling", () => {
-  afterEach(() => {
-    mock.timers.reset();
-  });
-
-  it("fetches fresh dashboard data again after every polling interval", async () => {
-    mock.timers.enable({ apis: ["Date", "setInterval"], now: 0 });
-
-    const first: DashboardData = {
-      source: "database",
-      updatedAt: "2026-04-26T10:00:00.000Z",
-      overall: [{ rank: 1, name: "Alpha", points: 100 }],
-      daily: [{ day: "Match 1", Alpha: 100 }],
-    };
-    const second: DashboardData = {
-      source: "database",
-      updatedAt: "2026-04-26T10:02:00.000Z",
-      overall: [{ rank: 1, name: "Alpha", points: 125 }],
-      daily: [{ day: "Match 1", Alpha: 125 }],
-    };
-    const responses = [first, second];
-    const received: DashboardData[] = [];
-    const fetchCalls: Array<{ url: string; options?: RequestInit }> = [];
-    const fetcher = (async (url: string, options?: RequestInit) => {
-      fetchCalls.push({ url, options });
-      return createResponse(responses.shift() ?? second);
-    }) as typeof fetch;
-
-    const stop = createDashboardPoller({
-      fetcher,
-      onData: (data) => received.push(data),
-      onError: (error) => assert.fail(String(error)),
-    });
-
-    await flushPromises();
-
-    assert.equal(fetchCalls.length, 1);
-    assert.equal(received.length, 1);
-    assert.equal(received[0].overall[0].points, 100);
-
-    mock.timers.tick(DASHBOARD_POLL_INTERVAL_MS);
-    await flushPromises();
-
-    assert.equal(fetchCalls.length, 2);
-    assert.equal(received.length, 2);
-    assert.equal(received[1].overall[0].points, 125);
-    assert.equal(fetchCalls[1].url, `/api/ipl?t=${DASHBOARD_POLL_INTERVAL_MS}`);
-    assert.deepEqual(fetchCalls[1].options, { cache: "no-store" });
-
-    stop();
-  });
-
-  it("does not emit unchanged data on the next interval", async () => {
-    mock.timers.enable({ apis: ["Date", "setInterval"], now: 0 });
-
-    const dashboard: DashboardData = {
-      source: "database",
-      updatedAt: "2026-04-26T10:00:00.000Z",
-      overall: [{ rank: 1, name: "Alpha", points: 100 }],
-      daily: [{ day: "Match 1", Alpha: 100 }],
-    };
-    const received: DashboardData[] = [];
-    const fetcher = (async () => createResponse(dashboard)) as typeof fetch;
-
-    const stop = createDashboardPoller({
-      fetcher,
-      onData: (data) => received.push(data),
-      onError: (error) => assert.fail(String(error)),
-    });
-
-    await flushPromises();
-    mock.timers.tick(DASHBOARD_POLL_INTERVAL_MS);
-    await flushPromises();
-
-    assert.equal(received.length, 1);
-
-    stop();
-  });
-});

package/template/tests/utils-and-cache.test.ts

@@ -1,267 +0,0 @@
-import assert from "node:assert/strict";
-import { afterEach, describe, it, mock } from "node:test";
-
-import { readDashboardCache, writeDashboardCache } from "../app/hooks/dashboardCache.ts";
-import { readSnapshotCache, writeSnapshotCache } from "../app/hooks/snapshotCache.ts";
-import {
-  getDisplayLiveMatchId,
-  getLiveUpdateRow,
-  getPlayedMatchRows,
-  hasMeaningfulMatchData,
-  parseMatchId,
-} from "../app/lib/dashboardData.ts";
-import { getMatchViewState } from "../app/lib/dashboardView.ts";
-import { getLatestMatchRow, hasLiveMatchRow } from "../app/lib/dashboardView.ts";
-import { matches } from "../app/lib/matches.ts";
-import { getDiff } from "../app/lib/utils/diff.ts";
-import { getStdDeviation } from "../app/lib/utils/getStdDeviation.ts";
-import { formatMatchTime, getMatchStatus, getTimeLeft } from "../app/lib/utils/time.ts";
-import { splitTeamName, trimTeamName } from "../app/lib/utils.ts";
-
-const createStorage = () => {
-  const store = new Map<string, string>();
-
-  return {
-    getItem: (key: string) => store.get(key) ?? null,
-    setItem: (key: string, value: string) => {
-      store.set(key, value);
-    },
-    removeItem: (key: string) => {
-      store.delete(key);
-    },
-    clear: () => {
-      store.clear();
-    },
-  };
-};
-
-describe("utility and cache coverage", () => {
-  afterEach(() => {
-    delete (globalThis as { window?: unknown }).window;
-    mock.timers.reset();
-  });
-
-  it("trims and splits team names across all branches", () => {
-    assert.equal(trimTeamName("Short"), "Short");
-    assert.equal(trimTeamName("VeryLongTeamName", 8), "VeryLong...");
-    assert.deepEqual(splitTeamName("Alpha"), ["Alpha", ""]);
-    assert.deepEqual(splitTeamName("Alpha Beta", 7), ["Alpha", "Beta"]);
-    assert.deepEqual(splitTeamName("NoSpacesHere", 4), ["NoSp", "acesHere"]);
-    assert.deepEqual(
-      splitTeamName("A very very long team name", 8),
-      ["A very", "very lon..."],
-    );
-  });
-
-  it("computes diffs and standard deviation", () => {
-    assert.deepEqual(
-      getDiff(
-        { a: 1, nested: { left: 2, same: 1 } },
-        { a: 2, nested: { left: 3, same: 1 }, added: true },
-      ),
-      {
-        a: 2,
-        "nested.left": 3,
-        added: true,
-      },
-    );
-    assert.equal(getStdDeviation([2, 4, 4, 4, 5, 5, 7, 9]), 2);
-  });
-
-  it("formats match times and covers all time status helpers", () => {
-    mock.timers.enable({ apis: ["Date"], now: new Date("2026-04-28T10:00:00.000Z") });
-
-    assert.match(
-      formatMatchTime("2026-04-28T14:00:00.000Z", "UTC"),
-      /28 Apr.*02:00 pm/i,
-    );
-    assert.equal(getMatchStatus("2026-04-28T05:30:00.000Z"), "ENDED");
-    assert.equal(getMatchStatus("2026-04-28T09:30:00.000Z"), "LIVE");
-    assert.equal(getMatchStatus("2026-04-28T10:20:00.000Z"), "STARTING SOON");
-    assert.equal(getMatchStatus("2026-04-28T12:00:00.000Z"), "UPCOMING");
-    assert.equal(getTimeLeft("2026-04-28T09:59:00.000Z"), "Started");
-    assert.equal(getTimeLeft("2026-04-28T10:45:00.000Z"), "45m");
-    assert.equal(getTimeLeft("2026-04-28T12:15:00.000Z"), "2h 15m");
-  });
-
-  it("normalizes dashboard daily rows for played matches and live match labels", () => {
-    const daily = [
-      { day: "Match 1", Alpha: 120, Beta: 90 },
-      { day: "Match 2", Alpha: 0, Beta: 0 },
-      { day: "Match 3", Alpha: 65, Beta: 55 },
-      { day: "Live Update", Alpha: 20, Beta: 18 },
-    ];
-
-    assert.equal(parseMatchId("Match 12"), 12);
-    assert.equal(parseMatchId("Live Update"), undefined);
-    assert.equal(hasMeaningfulMatchData(daily[0]), true);
-    assert.equal(hasMeaningfulMatchData(daily[1]), false);
-    assert.deepEqual(
-      getPlayedMatchRows(daily).map((row) => row.day),
-      ["Match 1", "Match 3"],
-    );
-    assert.equal(getLiveUpdateRow(daily)?.day, "Live Update");
-    assert.equal(getDisplayLiveMatchId(daily), 4);
-  });
-
-  it("falls back to the latest played row when no live match row exists", () => {
-    const daily = [
-      { day: "Match 1", Alpha: 10, Beta: 20 },
-      { day: "Match 2", Alpha: 15, Beta: 12 },
-    ];
-
-    assert.equal(hasLiveMatchRow(daily), false);
-    assert.equal(getLatestMatchRow(daily)?.day, "Match 2");
-    assert.equal(getMatchViewState(daily).isLive, false);
-    assert.equal(getMatchViewState(daily).latestRow?.day, "Match 2");
-    assert.equal(getMatchViewState(daily).hasMatches, true);
-  });
-
-  it("reads and writes dashboard cache with invalid payload safeguards", () => {
-    assert.equal(readDashboardCache(), null);
-    assert.doesNotThrow(() =>
-      writeDashboardCache({
-        source: "database",
-        overall: [],
-        daily: [],
-      }),
-    );
-
-    const storage = createStorage();
-    (globalThis as { window?: unknown }).window = {
-      localStorage: storage,
-    };
-
-    assert.equal(readDashboardCache(), null);
-
-    writeDashboardCache({
-      source: "database",
-      updatedAt: "2026-04-28T09:20:00.000Z",
-      snapshot: {
-        updatedAt: "2026-04-28T09:20:00.000Z",
-        leaders: [{ rank: 1, name: "Alpha", points: 120 }],
-      },
-      overall: [{ rank: 1, name: "Alpha", points: 120 }],
-      daily: [{ day: "Match 1", Alpha: 120 }],
-    });
-    const cached = readDashboardCache();
-    assert.ok(cached);
-    assert.equal(cached.data.overall[0].name, "Alpha");
-    assert.ok(cached.cachedAt);
-
-    storage.setItem(
-      "ipl:dashboard-cache:v1",
-      JSON.stringify({
-        data: { source: "database", overall: [], daily: [] },
-      }),
-    );
-    const fallbackCached = readDashboardCache();
-    assert.ok(fallbackCached);
-    assert.equal(typeof fallbackCached.cachedAt, "string");
-
-    storage.setItem(
-      "ipl:dashboard-cache:v1",
-      JSON.stringify({
-        cachedAt: "2026-04-28T09:20:00.000Z",
-        data: {
-          source: "database",
-          updatedAt: "2026-04-28T09:20:00.000Z",
-          overall: [],
-          daily: [],
-        },
-      }),
-    );
-    assert.equal(readDashboardCache(), null);
-
-    storage.setItem("ipl:dashboard-cache:v1", "{\"cachedAt\":1}");
-    assert.equal(readDashboardCache(), null);
-
-    storage.setItem("ipl:dashboard-cache:v1", "null");
-    assert.equal(readDashboardCache(), null);
-
-    storage.setItem("ipl:dashboard-cache:v1", "1");
-    assert.equal(readDashboardCache(), null);
-
-    storage.setItem("ipl:dashboard-cache:v1", JSON.stringify({ data: 1 }));
-    assert.equal(readDashboardCache(), null);
-
-    storage.setItem("ipl:dashboard-cache:v1", "not-json");
-    assert.equal(readDashboardCache(), null);
-  });
-
-  it("reads and writes snapshot cache with fallback timestamps", () => {
-    assert.equal(readSnapshotCache(), null);
-    assert.doesNotThrow(() =>
-      writeSnapshotCache({
-        leaders: [],
-      }),
-    );
-
-    const storage = createStorage();
-    (globalThis as { window?: unknown }).window = {
-      localStorage: storage,
-    };
-
-    assert.equal(readSnapshotCache(), null);
-
-    writeSnapshotCache({
-      updatedAt: "2026-04-28T09:15:00.000Z",
-      completedMatches: 41,
-      leaders: [{ rank: 1, name: "Alpha", points: 110 }],
-    });
-    const cached = readSnapshotCache();
-    assert.ok(cached);
-    assert.equal(cached.snapshot.leaders[0].name, "Alpha");
-    assert.ok(cached.cachedAt);
-
-    storage.setItem(
-      "ipl:snapshot-cache:v1",
-      JSON.stringify({
-        snapshot: { updatedAt: "2026-04-28T09:15:00.000Z", leaders: [] },
-      }),
-    );
-    const fallbackCached = readSnapshotCache();
-    assert.ok(fallbackCached);
-    assert.equal(typeof fallbackCached.cachedAt, "string");
-
-    storage.setItem("ipl:snapshot-cache:v1", "{\"cachedAt\":1}");
-    assert.equal(readSnapshotCache(), null);
-
-    storage.setItem("ipl:snapshot-cache:v1", "1");
-    assert.equal(readSnapshotCache(), null);
-
-    storage.setItem("ipl:snapshot-cache:v1", JSON.stringify({ snapshot: 1 }));
-    assert.equal(readSnapshotCache(), null);
-
-    storage.setItem("ipl:snapshot-cache:v1", "not-json");
-    assert.equal(readSnapshotCache(), null);
-  });
-
-  it("gracefully ignores cache write failures and exposes upcoming match data", () => {
-    (globalThis as { window?: unknown }).window = {
-      localStorage: {
-        getItem: () => null,
-        setItem: () => {
-          throw new Error("quota");
-        },
-      },
-    };
-
-    assert.doesNotThrow(() =>
-      writeDashboardCache({
-        source: "database",
-        overall: [],
-        daily: [],
-      }),
-    );
-    assert.doesNotThrow(() =>
-      writeSnapshotCache({
-        leaders: [],
-      }),
-    );
-
-    assert.equal(matches[0].id, 51);
-    assert.equal(matches.at(-1)?.id, 70);
-    assert.equal(matches.every((match) => match.team1 && match.team2 && match.date), true);
-  });
-});