@vatvaghool/create-ipl-dashboard 0.1.20 → 0.1.24

package/template/tests/coverage-gaps.test.ts

@@ -1,290 +0,0 @@
-import assert from "node:assert/strict";
-import { afterEach, describe, it, mock } from "node:test";
-
-import type { DashboardData, RawApiUser } from "../app/types.ts";
-import {
-  addLeaderboardMetrics,
-  buildManualDashboard,
-  normalizePayload,
-  normalizeRawApiUsers,
-  syncRawUsersWithSnapshot,
-} from "../app/api/ipl/transform.ts";
-import { createDashboardPoller } from "../app/hooks/dashboardPolling.ts";
-
-const flushPromises = () => new Promise<void>((resolve) => queueMicrotask(resolve));
-
-describe("coverage gap guards", () => {
-  afterEach(() => {
-    mock.timers.reset();
-  });
-
-  it("normalizes date instances and filters malformed squad/player records", () => {
-    const updatedAt = new Date("2026-04-28T09:15:00.000Z");
-    const payload = normalizePayload({
-      updatedAt,
-      leaders: [
-        {
-          rank: 1,
-          name: "Alpha",
-          points: 110,
-          captain: { playerName: "Captain A", id: 7, playerPoints: 44 },
-          viceCaptain: { fullName: "Vice A", playerId: "11", pts: 22 },
-          players: [
-            { name: "Valid Player", number: "08", points: 20 },
-            { playerName: "Bench Player", id: 19, playerPoints: 5 },
-            { number: "99", points: 3 },
-            "",
-            null,
-          ],
-        },
-      ],
-    });
-
-    assert.ok(payload);
-    assert.equal(payload.updatedAt, updatedAt.toISOString());
-    assert.equal(payload.leaders[0].captain?.name, "Captain A");
-    assert.equal(payload.leaders[0].captain?.number, "7");
-    assert.equal(payload.leaders[0].captain?.points, 44);
-    assert.equal(payload.leaders[0].viceCaptain?.name, "Vice A");
-    assert.equal(payload.leaders[0].viceCaptain?.number, "11");
-    assert.deepEqual(payload.leaders[0].players, [
-      { name: "Valid Player", number: "08", points: 20 },
-      { name: "Bench Player", number: "19", points: 5 },
-    ]);
-  });
-
-  it("keeps completed match count undefined when a valid payload reports zero", () => {
-    const payload = normalizePayload({
-      completedMatches: 0,
-      Meta: {
-        Timestamp: {
-          ISTTime: "2026-04-28T09:15:00.000Z",
-        },
-      },
-      leaders: [{ rank: 1, name: "Alpha", points: 110 }],
-    });
-
-    assert.ok(payload);
-    assert.equal(payload.completedMatches, undefined);
-    assert.equal(payload.updatedAt, "2026-04-28T09:15:00.000Z");
-  });
-
-  it("parses completed matches from feed text and handles single-row leaderboard metrics", () => {
-    const payload = normalizePayload({
-      Data: {
-        Value: [{ rank: 1, usrname: "Solo", points: 77 }],
-        FeedTime: {
-          UTCTime: "Match 12",
-        },
-      },
-    });
-
-    assert.ok(payload);
-    assert.equal(payload.completedMatches, 12);
-
-    const rows = addLeaderboardMetrics([
-      { rank: 1, name: "Solo", points: 77, transfersLeft: 210 },
-    ]);
-
-    assert.deepEqual(rows, [
-      {
-        name: "Solo",
-        points: 77,
-        rank: 1,
-        previousRank: 1,
-        previousPoints: 77,
-        lastMatchPoints: undefined,
-        gapToNext: 0,
-        gapPercent: 0,
-        movement: "same",
-        transfersLeft: 210,
-        transfersUsed: undefined,
-        totalTransfers: undefined,
-        boostersUsed: undefined,
-        efficiency: undefined,
-        isLastMatchLeader: false,
-        captain: undefined,
-        viceCaptain: undefined,
-        players: undefined,
-      },
-    ]);
-  });
-
-  it("rejects invalid raw user payload shapes and invalid match rows", () => {
-    assert.equal(normalizeRawApiUsers({ nope: true }), null);
-
-    const normalized = normalizeRawApiUsers([
-      null,
-      {
-        rno: 1,
-        temname: "Alpha",
-        matches: [
-          null,
-          { matchId: "bad", points: 10 },
-          { matchId: 1, points: "bad" },
-          { matchId: 2, points: 25 },
-        ],
-      },
-      {
-        rno: 2,
-        temname: "No Matches Array",
-      },
-    ]);
-
-    assert.deepEqual(normalized, [
-      {
-        rno: 1,
-        temname: "Alpha",
-        points: 25,
-        matches: [{ matchId: 2, points: 25 }],
-      },
-    ]);
-  });
-
-  it("builds an empty manual dashboard and appends future matches without live points", () => {
-    assert.deepEqual(buildManualDashboard([]), {
-      overall: [],
-      daily: [],
-      completedMatches: undefined,
-      source: "database",
-    });
-
-    const users: RawApiUser[] = [
-      {
-        rno: 1,
-        temname: "Alpha",
-        points: 30,
-        matches: [{ matchId: 1, points: 30 }],
-      },
-    ];
-
-    const result = syncRawUsersWithSnapshot(users, {
-      updatedAt: "2026-04-28T09:15:00.000Z",
-      completedMatches: 3,
-      leaders: [{ rank: 1, name: "Alpha", points: 45 }],
-    });
-
-    assert.equal(result.status, "updated");
-    assert.equal(result.mode, "append");
-    assert.deepEqual(result.users[0].matches, [
-      { matchId: 1, points: 30 },
-      { matchId: 2, points: 15 },
-    ]);
-  });
-
-  it("returns skipped when snapshot leaders do not match raw users", () => {
-    const users: RawApiUser[] = [
-      {
-        rno: 1,
-        temname: "Alpha",
-        points: 100,
-        matches: [{ matchId: 1, points: 100 }],
-      },
-    ];
-
-    const result = syncRawUsersWithSnapshot(users, {
-      updatedAt: "2026-04-28T09:15:00.000Z",
-      completedMatches: 2,
-      leaders: [{ rank: 1, name: "Ghost Team", points: 150 }],
-    });
-
-    assert.deepEqual(result, {
-      status: "skipped",
-      users,
-      unmatchedNames: ["Ghost Team"],
-    });
-  });
-
-  it("creates a latest match row when forcing update-latest without an existing match entry", () => {
-    const users: RawApiUser[] = [
-      {
-        rno: 1,
-        temname: "Alpha",
-        points: 10,
-        matches: [{ matchId: 1, points: 10 }],
-      },
-      {
-        rno: 2,
-        temname: "Beta",
-        points: 15,
-        matches: [{ matchId: 1, points: 15 }],
-      },
-    ];
-
-    const result = syncRawUsersWithSnapshot(users, {
-      updatedAt: "2026-04-28T09:15:00.000Z",
-      completedMatches: 2,
-      leaders: [
-        { rank: 1, name: "Beta", points: 15, lastMatchPoints: 0 },
-        { rank: 2, name: "Alpha", points: 18, lastMatchPoints: 8 },
-      ],
-    });
-
-    assert.equal(result.status, "updated");
-    assert.equal(result.mode, "append");
-    assert.equal(result.matchId, 2);
-    assert.deepEqual(result.users[0].matches, [
-      { matchId: 1, points: 10 },
-      { matchId: 2, points: 8 },
-    ]);
-  });
-
-  it("reports polling fetch failures and does not emit stale data after stop", async () => {
-    mock.timers.enable({ apis: ["Date", "setInterval"], now: 0 });
-
-    const errors: unknown[] = [];
-    const received: DashboardData[] = [];
-    let resolveFetch: ((value: Response) => void) | undefined;
-
-    const fetcher = (async (url: string) => {
-      if (url.includes("first")) {
-        return {
-          ok: false,
-          status: 503,
-          json: async () => ({}),
-        } as Response;
-      }
-
-      return await new Promise<Response>((resolve) => {
-        resolveFetch = resolve;
-      });
-    }) as typeof fetch;
-
-    let firstCall = true;
-    const wrappedFetcher = (async (url: string, options?: RequestInit) => {
-      const actualUrl = firstCall ? "/api/ipl?first=true" : url;
-      firstCall = false;
-      return fetcher(actualUrl, options);
-    }) as typeof fetch;
-
-    const stop = createDashboardPoller({
-      fetcher: wrappedFetcher,
-      onData: (data) => received.push(data),
-      onError: (error) => errors.push(error),
-      intervalMs: 50,
-    });
-
-    await flushPromises();
-    await flushPromises();
-    assert.equal(errors.length, 1);
-    assert.match(String(errors[0]), /503/);
-
-    mock.timers.tick(50);
-    stop();
-
-    resolveFetch?.({
-      ok: true,
-      status: 200,
-      json: async () =>
-        ({
-          source: "database",
-          updatedAt: "2026-04-28T09:20:00.000Z",
-          overall: [{ rank: 1, name: "Alpha", points: 120 }],
-          daily: [{ day: "Match 1", Alpha: 120 }],
-        }) as DashboardData,
-    } as Response);
-
-    await flushPromises();
-    assert.equal(received.length, 0);
-  });
-});

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);
-  });
-});