HiveGrid-Wireframes/hivegrid-cloud/scripts/verify-platform-admin-dashboard-baseline.test.mjs

import { mkdtemp, mkdir, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { describe, expect, it } from "vitest";

import { failureCount, gates, platformAdminDashboardInventoryScanRoots, renderReport, reportPath, runPlatformAdminDashboardInventory } from "./verify-platform-admin-dashboard-baseline.mjs";

const focusedSmokeTargets = [
  "packages/db/src/index.test.ts",
  "packages/db/src/subscriptions-boundary.test.ts",
  "packages/entitlements/src/index.test.ts",
  "apps/web/app/routes/admin.host-aware.test.ts",
  "apps/web/app/routes/app.$tenant.host-aware.test.ts",
];

describe("Platform Admin Dashboard baseline runner configuration", () => {
  it("defines the required non-E2E gates and report path", () => {
    expect(reportPath).toMatch(/\.tc\/baselines\/platform-admin-dashboard\/baseline-health\.md$/);
    expect(gates.map((gate) => gate.id)).toEqual(["typecheck", "lint", "vitest-platformAdminDashboard-smoke", "platformAdminDashboard-platform-inventory"]);
    expect(gates.some((gate) => gate.args?.some((arg) => /playwright|cypress|browser|e2e/i.test(arg)))).toBe(false);
    expect(platformAdminDashboardInventoryScanRoots).toEqual(["apps/web/app/routes", "apps/web/app/components", "apps/web/app/utils", "packages/db/src", "packages/entitlements/src", "prisma"]);
  });

  it("keeps focused smoke tests in the Vitest gate", () => {
    const vitestGate = gates.find((gate) => gate.id === "vitest-platformAdminDashboard-smoke");

    expect(vitestGate?.args).toEqual(["exec", "vitest", "run", ...focusedSmokeTargets]);
  });
});

describe("Platform Admin Dashboard baseline runner failure counting", () => {
  it("counts failed typecheck diagnostics conservatively", () => {
    expect(failureCount("typecheck", "src/a.ts(1,1): error TS2307: Cannot find module\nsrc/b.ts(2,2): error TS2322: Type mismatch", "", 1)).toBe(2);
    expect(failureCount("typecheck", "Build failed", "", 1)).toBe(1);
  });

  it("counts failed ESLint diagnostics conservatively", () => {
    expect(failureCount("lint", "✖ 4 problems (3 errors, 1 warning)", "", 1)).toBe(3);
    expect(failureCount("lint", "2 errors and 0 warnings", "", 1)).toBe(2);
    expect(failureCount("lint", "Lint crashed", "", 1)).toBe(1);
  });

  it("counts failed Vitest diagnostics conservatively", () => {
    expect(failureCount("vitest-platformAdminDashboard-smoke", "Tests 2 failed | 8 passed", "", 1)).toBe(2);
    expect(failureCount("vitest-platformAdminDashboard-smoke", "Test Files 1 failed | 2 passed", "", 1)).toBe(1);
    expect(failureCount("vitest-platformAdminDashboard-smoke", "Vitest crashed", "", 1)).toBe(1);
  });

  it("returns zero for clean exits and read-only inventory gates", () => {
    expect(failureCount("lint", "warning only", "", 0)).toBe(0);
    expect(failureCount("platformAdminDashboard-platform-inventory", "total matches: 12", "", 1)).toBe(0);
  });
});

describe("Platform Admin Dashboard inventory scan", () => {
  it("scans existing roots, records missing roots, and ignores generated dependency and TC paths", async () => {
    const root = await mkdtemp(join(tmpdir(), "platformAdminDashboard-baseline-inventory-"));
    await mkdir(join(root, "apps", "web", "app", "routes"), { recursive: true });
    await mkdir(join(root, "apps", "web", "app", "components"), { recursive: true });
    await mkdir(join(root, "packages", "db", "src"), { recursive: true });
    await mkdir(join(root, ".tc"), { recursive: true });
    await mkdir(join(root, "apps", "web", "app", "routes", "generated"), { recursive: true });
    await mkdir(join(root, "node_modules", "ignored"), { recursive: true });

    const signal = [
      "const adminSettings = 'Platform admin settings';",
      "const kpi = 'KPI dashboard stats and revenue $12,345 growth 42%';",
      "const workspaceDashboard = 'Tenant workspace dashboard';",
      "const entitlement = 'feature gate plan subscription quota';",
      "const audit = 'audit log history';",
    ].join("\n");
    const ignoredSignal = "adminSettings KPI workspaceDashboard entitlement audit $99 15%";

    await writeFile(join(root, "apps", "web", "app", "routes", "dashboard.tsx"), signal, "utf8");
    await writeFile(join(root, "apps", "web", "app", "components", "Stats.tsx"), "export const total = '$1,000';", "utf8");
    await writeFile(join(root, "packages", "db", "src", "schema.ts"), "export const plan = 'subscription plan';", "utf8");
    await writeFile(join(root, ".tc", "ignored.tsx"), ignoredSignal, "utf8");
    await writeFile(join(root, "apps", "web", "app", "routes", "generated", "ignored.tsx"), ignoredSignal, "utf8");
    await writeFile(join(root, "node_modules", "ignored", "ignored.tsx"), ignoredSignal, "utf8");

    const inventory = await runPlatformAdminDashboardInventory(root);
    const allMatches = inventory.matches.join("\n");

    expect(inventory.roots).toEqual(["apps/web/app/routes", "apps/web/app/components", "packages/db/src"]);
    expect(inventory.missingRoots).toEqual(["apps/web/app/utils", "packages/entitlements/src", "prisma"]);
    expect(inventory.counts).toMatchObject({
      "platform-admin-settings": 3,
      "kpi-dashboard-stats": 3,
      "tenant-workspace-dashboard": 4,
      "entitlement-feature-plan-gating": 8,
      "audit-log": 3,
      "hardcoded-dashboard-value": 2,
    });
    expect(allMatches).toContain("apps/web/app/routes/dashboard.tsx");
    expect(allMatches).toContain("apps/web/app/components/Stats.tsx");
    expect(allMatches).toContain("packages/db/src/schema.ts");
    expect(allMatches).not.toContain(".tc/ignored.tsx");
    expect(allMatches).not.toContain("generated/ignored.tsx");
    expect(allMatches).not.toContain("node_modules/ignored/ignored.tsx");
  });
});

describe("Platform Admin Dashboard report rendering", () => {
  it("renders gate metadata, fingerprints, and inventory counts", () => {
    const report = renderReport([
      { id: "typecheck", command: "pnpm run typecheck", exitCode: 2, durationMs: 1500, failureCount: 7, fingerprint: { hash: "abc123def456", excerpt: "error TS2322" } },
      {
        id: "platformAdminDashboard-platform-inventory",
        command: "read-only Platform Admin Dashboard platform/admin/KPI/dashboard/entitlement inventory",
        exitCode: 0,
        durationMs: 42,
        failureCount: 0,
        inventory: {
          roots: ["apps/web/app/routes"],
          missingRoots: ["prisma"],
          filesScanned: 3,
          counts: { "platform-admin-settings": 1, "kpi-dashboard-stats": 2 },
          totalMatches: 3,
          matches: [],
        },
        fingerprint: { hash: "fed456abc123", excerpt: "platform-admin-settings: 1" },
      },
    ]);

    expect(report).toContain("# Platform Admin Dashboard Baseline Health");
    expect(report).toContain("non-E2E baseline gates for Platform Admin Dashboard baseline");
    expect(report).toContain("platform/admin settings, KPI/dashboard stats");
    expect(report).toContain("## typecheck");
    expect(report).toContain("## platformAdminDashboard-platform-inventory");
    expect(report).toContain("- Exitcode: 2");
    expect(report).toContain("- Failure Count: 7");
    expect(report).toContain("- Output Fingerprint: abc123def456");
    expect(report).toContain("- Inventory Roots: apps/web/app/routes");
    expect(report).toContain("- Missing Roots Skipped: prisma");
    expect(report).toContain("  - platform-admin-settings: 1");
    expect(report).toContain("- Total Inventory Matches: 3");
  });
});