@vatvaghool/create-ipl-dashboard 0.1.0

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

@@ -0,0 +1,290 @@
+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

@@ -0,0 +1,96 @@
+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/detailed-data.test.ts

@@ -0,0 +1,60 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import { buildDetailedTableRows } from "../app/lib/detailedData.ts";
+
+describe("detailed data rows", () => {
+  it("prefers transfer snapshot data for transfers and boosters", () => {
+    const rows = buildDetailedTableRows({
+      overall: [
+        {
+          name: "Alpha",
+          points: 120,
+          rank: 1,
+          lastMatchPoints: 18,
+        },
+      ],
+      latestDailyRow: {
+        day: "Live Update",
+        Alpha: 21,
+      },
+      snapshotLeaders: [
+        {
+          rank: 1,
+          name: "Alpha",
+          points: 120,
+          transfersLeft: 101,
+          boostersUsed: "1",
+        },
+      ],
+      transfers: {
+        updatedAt: "2026-05-11T10:30:00.000Z",
+        teams: [
+          {
+            team: "Alpha",
+            matchesPlayed: 12,
+            boostersUsed: 2,
+            transfersLeft: "94",
+            updatedAt: "2026-05-11T10:30:00.000Z",
+          },
+        ],
+      },
+    });
+
+    assert.deepEqual(rows, [
+      {
+        name: "Alpha",
+        points: 120,
+        rank: 1,
+        lastMatchPoints: 18,
+        latestPoints: 21,
+        transfersLeft: 94,
+        transfersUsed: 66,
+        totalTransfers: 160,
+        efficiency: 120 / 66,
+        boostersUsed: "2",
+        transferMatchesPlayed: 12,
+      },
+    ]);
+  });
+});