Ekklesia/apps/api/tests/dashboard-host-assets.test.ts

import { createHash } from "node:crypto";
import { beforeEach, describe, expect, it, vi } from "vitest";

const readFileMock = vi.hoisted(() => vi.fn());

vi.mock("node:fs/promises", () => ({ readFile: readFileMock }));
vi.mock("@ekklesia/shell/dashboard-assets", () => ({
  dashboardHostAssetUrls: Object.freeze({
    html: "file:///surface/browser/index.html",
    script: "file:///surface/browser/assets/ekklesia-dashboard/app.js",
    appearance: "file:///surface/browser/assets/ekklesia-dashboard/appearance.js",
  }),
}));

import {
  createDashboardHostAssets,
  DASHBOARD_API_ORIGIN_PLACEHOLDER,
  DashboardHostAssetError,
  loadDashboardHostAssets,
  renderDashboardPage,
} from "../src/dashboard-host-assets.js";

const API_ORIGIN = "https://api.example.test";

function sha256Etag(text: string): string {
  return `"${createHash("sha256").update(text).digest("base64url")}"`;
}

describe("Dashboard host asset loading", () => {
  beforeEach(() => readFileMock.mockReset());

  it("reads only the three declared file URLs in order and freezes one consistent snapshot", async () => {
    const html = `<!doctype html>${DASHBOARD_API_ORIGIN_PLACEHOLDER}<div id="ekklesia-host"></div>`;
    const script = "export const dashboardHost = true;\n";
    const appearanceScript = "(() => {})();\n";
    readFileMock
      .mockResolvedValueOnce(html)
      .mockResolvedValueOnce(script)
      .mockResolvedValueOnce(appearanceScript);

    const assets = await loadDashboardHostAssets(API_ORIGIN);

    expect(readFileMock.mock.calls).toEqual([
      [new URL("file:///surface/browser/index.html"), "utf8"],
      [new URL("file:///surface/browser/assets/ekklesia-dashboard/app.js"), "utf8"],
      [new URL("file:///surface/browser/assets/ekklesia-dashboard/appearance.js"), "utf8"],
    ]);
    const rendered = `<!doctype html><meta content="${API_ORIGIN}" name="ekklesia-api-origin" /><div id="ekklesia-host"></div>`;
    expect(assets).toEqual({
      appearanceScript,
      appearanceScriptEtag: sha256Etag(appearanceScript),
      html: rendered,
      htmlEtag: sha256Etag(rendered),
      script,
      scriptEtag: sha256Etag(script),
    });
    expect(Object.isFrozen(assets)).toBe(true);
  });

  it("fails deterministically without attempting a neighboring file or exposing the read error", async () => {
    readFileMock.mockRejectedValueOnce(
      new Error("ENOENT /home/operator/private/surface-build secret-token"),
    );

    const failure = await loadDashboardHostAssets(API_ORIGIN).catch((error: unknown) => error);

    expect(readFileMock).toHaveBeenCalledTimes(1);
    expect(failure).toBeInstanceOf(DashboardHostAssetError);
    expect(failure).toMatchObject({
      code: "DASHBOARD_HOST_ASSET_UNAVAILABLE",
      message: "The Dashboard host browser assets are unavailable.",
      name: "DashboardHostAssetError",
    });
    expect((failure as Error).stack).toBe(
      "DashboardHostAssetError: The Dashboard host browser assets are unavailable.",
    );
    const publicText = `${String(failure)}\n${JSON.stringify(failure)}\n${(failure as Error).stack}`;
    for (const secret of ["/home/", "operator", "ENOENT", "secret-token"]) {
      expect(publicText).not.toContain(secret);
    }
  });

  it("fails when the script is missing even though the page was read", async () => {
    readFileMock
      .mockResolvedValueOnce(`<!doctype html>${DASHBOARD_API_ORIGIN_PLACEHOLDER}`)
      .mockRejectedValueOnce(new Error("ENOENT app.js"));

    await expect(loadDashboardHostAssets(API_ORIGIN)).rejects.toBeInstanceOf(
      DashboardHostAssetError,
    );
    expect(readFileMock).toHaveBeenCalledTimes(2);
  });

  it("fails when the appearance script is missing even though the page and script were read", async () => {
    readFileMock
      .mockResolvedValueOnce(`<!doctype html>${DASHBOARD_API_ORIGIN_PLACEHOLDER}`)
      .mockResolvedValueOnce("export {};\n")
      .mockRejectedValueOnce(new Error("ENOENT appearance.js"));

    await expect(loadDashboardHostAssets(API_ORIGIN)).rejects.toBeInstanceOf(
      DashboardHostAssetError,
    );
    expect(readFileMock).toHaveBeenCalledTimes(3);
  });

  it("rejects an empty page, script, or appearance script as an unavailable shell build", () => {
    for (const [html, script, appearance] of [
      ["", "export {};", "(() => {})();"],
      ["<html></html>", "   \n", "(() => {})();"],
      ["<html></html>", "export {};", " "],
    ] as const) {
      expect(() => createDashboardHostAssets(html, script, appearance)).toThrow(
        DashboardHostAssetError,
      );
    }
  });

  it("fails startup on a page without exactly one empty API-origin element (ADR 0045)", async () => {
    for (const html of [
      "<!doctype html>",
      `<!doctype html>${DASHBOARD_API_ORIGIN_PLACEHOLDER}${DASHBOARD_API_ORIGIN_PLACEHOLDER}`,
      '<!doctype html><meta content="https://elsewhere.test" name="ekklesia-api-origin" />',
    ]) {
      readFileMock.mockReset();
      readFileMock
        .mockResolvedValueOnce(html)
        .mockResolvedValueOnce("export {};\n")
        .mockResolvedValueOnce("(() => {})();\n");
      await expect(loadDashboardHostAssets(API_ORIGIN)).rejects.toBeInstanceOf(
        DashboardHostAssetError,
      );
    }
  });
});

describe("Dashboard page API origin (ADR 0045)", () => {
  const page = `<head>${DASHBOARD_API_ORIGIN_PLACEHOLDER}</head>`;

  it("writes the API's origin into the one placeholder, in either topology", () => {
    expect(renderDashboardPage(page, "https://api.example.test")).toBe(
      '<head><meta content="https://api.example.test" name="ekklesia-api-origin" /></head>',
    );
    expect(renderDashboardPage(page, "http://127.0.0.1:3000")).toBe(
      '<head><meta content="http://127.0.0.1:3000" name="ekklesia-api-origin" /></head>',
    );
  });

  it.each([
    "https://api.example.test/",
    "https://api.example.test/api",
    'https://api.example.test"><script>',
    "javascript:alert(1)",
    "",
  ])("refuses a value that is not a canonical http(s) origin: %s", (origin) => {
    expect(() => renderDashboardPage(page, origin)).toThrow(DashboardHostAssetError);
  });
});