@app-vitals/agent-runtime 0.0.1 → 0.1.0

package/github-installations-reporter.unit.test.ts

@@ -0,0 +1,166 @@
+/**
+ * Unit tests for HttpGitHubInstallationsReporter: change detection, heartbeat
+ * (injected Clock), payload hygiene, and never-throws behavior.
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { InstallationsSnapshot } from "./github-installations.ts";
+import {
+  HttpGitHubInstallationsReporter,
+  INSTALLATIONS_HEARTBEAT_MS,
+  NoopGitHubInstallationsReporter,
+  startInstallationsHeartbeat,
+} from "./github-installations-reporter.ts";
+
+function snap(
+  health: "ok" | "broken" | "unknown" = "ok",
+  extra: InstallationsSnapshot["installations"] = [],
+): InstallationsSnapshot {
+  return {
+    defaultId: 1,
+    installations: [
+      {
+        id: 1,
+        owner: "acme",
+        pinned: false,
+        health,
+        reason: health === "broken" ? "mint_rejected" : null,
+      },
+      ...extra,
+    ],
+  };
+}
+
+function harness(responses: (Response | Error)[] = []) {
+  let nowMs = Date.UTC(2026, 0, 1);
+  const calls: { url: string; init: RequestInit | undefined }[] = [];
+  let i = 0;
+  const fetchFn = (async (input: RequestInfo | URL, init?: RequestInit) => {
+    calls.push({ url: String(input), init });
+    const r = responses[i++] ?? new Response("{}", { status: 200 });
+    if (r instanceof Error) throw r;
+    return r;
+  }) as unknown as typeof fetch;
+  const reporter = new HttpGitHubInstallationsReporter({
+    apiUrl: "http://api",
+    agentId: "a1",
+    apiKey: "KEY",
+    fetchFn,
+    clock: { now: () => new Date(nowMs) },
+  });
+  return {
+    reporter,
+    calls,
+    advance: (ms: number) => {
+      nowMs += ms;
+    },
+  };
+}
+
+describe("HttpGitHubInstallationsReporter", () => {
+  test("first report PUTs a full snapshot", async () => {
+    const h = harness();
+    await h.reporter.report(snap());
+    expect(h.calls).toHaveLength(1);
+    expect(h.calls[0].url).toBe("http://api/agents/a1/github-installations");
+    expect(h.calls[0].init?.method).toBe("PUT");
+    const body = JSON.parse(String(h.calls[0].init?.body));
+    expect(body.installations).toEqual([
+      { owner: "acme", installationId: 1, state: "ok", lastError: null },
+    ]);
+  });
+
+  test("unchanged state inside heartbeat window posts nothing", async () => {
+    const h = harness();
+    await h.reporter.report(snap());
+    h.advance(60_000);
+    await h.reporter.report(snap());
+    expect(h.calls).toHaveLength(1);
+  });
+
+  test("ok -> broken -> ok each post", async () => {
+    const h = harness();
+    await h.reporter.report(snap("ok"));
+    await h.reporter.report(snap("broken"));
+    await h.reporter.report(snap("ok"));
+    expect(h.calls).toHaveLength(3);
+    const broken = JSON.parse(String(h.calls[1].init?.body));
+    expect(broken.installations[0].state).toBe("broken");
+    expect(broken.installations[0].lastError).toBe(
+      "installation token mint rejected",
+    );
+  });
+
+  test("discovered and removed installations post", async () => {
+    const h = harness();
+    await h.reporter.report(snap());
+    const added = snap("ok", [
+      { id: 2, owner: null, pinned: true, health: "unknown", reason: null },
+    ]);
+    await h.reporter.report(added);
+    await h.reporter.report(snap());
+    expect(h.calls).toHaveLength(3);
+    expect(
+      JSON.parse(String(h.calls[1].init?.body)).installations[1].owner,
+    ).toBe("unknown");
+  });
+
+  test("heartbeat re-posts unchanged state after 30 minutes", async () => {
+    const h = harness();
+    await h.reporter.report(snap());
+    h.advance(INSTALLATIONS_HEARTBEAT_MS - 1);
+    await h.reporter.report(snap());
+    expect(h.calls).toHaveLength(1);
+    h.advance(1);
+    await h.reporter.report(snap());
+    expect(h.calls).toHaveLength(2);
+  });
+
+  test("non-2xx and thrown fetch never throw, and retry next report", async () => {
+    const h = harness([
+      new Response("secret body", { status: 500 }),
+      new Error("boom"),
+    ]);
+    await h.reporter.report(snap());
+    await h.reporter.report(snap());
+    await h.reporter.report(snap());
+    expect(h.calls).toHaveLength(3);
+  });
+
+  test("payload carries no token, key, or response material", async () => {
+    const h = harness();
+    await h.reporter.report(snap("broken"));
+    const raw = String(h.calls[0].init?.body);
+    expect(Object.keys(JSON.parse(raw)).sort()).toEqual([
+      "installations",
+      "reportedAt",
+    ]);
+    expect(raw).not.toMatch(/ghs_|BEGIN|"token"|"key"/);
+  });
+});
+
+describe("startInstallationsHeartbeat", () => {
+  test("ticks report the current state; stop clears the timer", async () => {
+    const reports: InstallationsSnapshot[] = [];
+    let tick: () => void = () => {};
+    const stop = startInstallationsHeartbeat(
+      { report: async (s) => void reports.push(s) },
+      () => snap(),
+      {
+        setIntervalFn: ((fn: () => void) => {
+          tick = fn;
+          return 0;
+        }) as unknown as typeof setInterval,
+      },
+    );
+    tick();
+    expect(reports).toHaveLength(1);
+    stop();
+  });
+});
+
+describe("NoopGitHubInstallationsReporter", () => {
+  test("resolves without effect", async () => {
+    await new NoopGitHubInstallationsReporter().report(snap());
+  });
+});

package/github-installations.integration.test.ts

@@ -0,0 +1,88 @@
+/**
+ * Integration tests for discoverInstallations/selectInstallations using a
+ * recorded cassette of GET /app/installations (multi-page, a suspended
+ * installation, and a user installation not created via admin) replayed
+ * through an injected fetchFn. No real network.
+ */
+
+import { describe, expect, it } from "bun:test";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+  discoverInstallations,
+  selectInstallations,
+} from "./github-installations.ts";
+
+interface CassetteEntry {
+  status: number;
+  body: unknown;
+}
+
+const cassette: Record<string, CassetteEntry> = JSON.parse(
+  readFileSync(
+    // Beside the runtime source when extracted, one level up in the monorepo.
+    [join(import.meta.dir, "fixtures"), join(import.meta.dir, "..", "fixtures")]
+      .map((dir) => join(dir, "github-installations", "installations.json"))
+      .find((path) => existsSync(path)) as string,
+    "utf-8",
+  ),
+);
+
+function replay(keyForPage: (page: number) => string) {
+  const requests: { url: string; auth: string | null }[] = [];
+  const fetchFn = (async (url: string | URL | Request, init?: RequestInit) => {
+    const u = new URL(String(url));
+    requests.push({
+      url: String(url),
+      auth: new Headers(init?.headers).get("Authorization"),
+    });
+    const entry = cassette[keyForPage(Number(u.searchParams.get("page")))];
+    return new Response(JSON.stringify(entry.body), {
+      status: entry.status,
+      statusText: `status-${entry.status}`,
+    });
+  }) as typeof fetch;
+  return { fetchFn, requests };
+}
+
+describe("discoverInstallations (cassette)", () => {
+  it("follows pagination across pages with the App JWT only", async () => {
+    const { fetchFn, requests } = replay((p) =>
+      p === 1 ? "page1_full" : "page2_partial",
+    );
+    const r = await discoverInstallations("app-jwt", fetchFn);
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    expect(r.installations).toHaveLength(101);
+    expect(requests).toHaveLength(2);
+    expect(requests[0].url).toContain("per_page=100&page=1");
+    expect(requests.every((q) => q.auth === "Bearer app-jwt")).toBe(true);
+    expect(
+      r.installations.find((i) => i.id === 1005)?.suspendedAt,
+    ).not.toBeNull();
+    expect(r.installations.find((i) => i.id === 2001)?.owner).toBe("octocat");
+  });
+
+  it("returns an error result on a 401", async () => {
+    const { fetchFn } = replay(() => "unauthorized");
+    const r = await discoverInstallations("bad", fetchFn);
+    expect(r.ok).toBe(false);
+    if (!r.ok) expect(r.error).toContain("401");
+  });
+
+  it("feeds selection: out-of-scope ignored, suspended flagged, non-admin install selected", async () => {
+    const { fetchFn } = replay((p) =>
+      p === 1 ? "page1_full" : "page2_partial",
+    );
+    const r = await discoverInstallations("jwt", fetchFn);
+    if (!r.ok) throw new Error("discovery failed");
+    const sel = selectInstallations({
+      discovered: r.installations,
+      scopedRepos: ["acme-corp/app", "suspended-org/x", "octocat/dotfiles"],
+      scopeSynced: true,
+    });
+    expect(sel.installations.map((i) => i.id)).toEqual([1003, 1005, 2001]);
+    expect(sel.installations.find((i) => i.id === 1005)?.suspended).toBe(true);
+    expect(sel.defaultId).toBe(1003);
+  });
+});