git-daemon 0.1.8 → 0.1.10

package/tests/app.test.ts

@@ -1,15 +1,47 @@
-import { describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it } from "vitest";
 import request from "supertest";
 import path from "path";
 import os from "os";
 import { promises as fs } from "fs";
 import pino from "pino";
 import { execa } from "execa";
+import type { Server } from "http";
 import { createApp, type DaemonContext } from "../src/app";
 import { TokenStore } from "../src/tokens";
 import { PairingManager } from "../src/pairing";
 import { JobManager } from "../src/jobs";
 import type { AppConfig } from "../src/types";
+import { HealthcheckResultStore } from "../src/healthchecks";
+
+const servers: Server[] = [];
+
+const createHttpServer = (app: ReturnType<typeof createApp>) =>
+  new Promise<Server>((resolve, reject) => {
+    const server = app.listen(0, "127.0.0.1");
+    server.once("listening", () => {
+      servers.push(server);
+      resolve(server);
+    });
+    server.once("error", (err) => {
+      reject(err);
+    });
+  });
+
+const closeServer = (server: Server) =>
+  new Promise<void>((resolve, reject) => {
+    server.close((err) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve();
+    });
+  });
+
+afterEach(async () => {
+  const closing = servers.splice(0, servers.length).map(closeServer);
+  await Promise.all(closing);
+});
 
 const createTempDir = async () =>
   fs.mkdtemp(path.join(os.tmpdir(), "git-daemon-test-"));
@@ -43,6 +75,7 @@ const setupRepoWithRemote = async (workspaceRoot: string) => {
 const createConfig = (
   workspaceRoot: string | null,
   origin: string,
+  healthchecks?: AppConfig["healthchecks"],
 ): AppConfig => ({
   configVersion: 1,
   server: { host: "127.0.0.1", port: 0 },
@@ -51,13 +84,18 @@ const createConfig = (
   pairing: { tokenTtlDays: 30 },
   jobs: { maxConcurrent: 1, timeoutSeconds: 60 },
   deps: { defaultSafer: true },
+  healthchecks,
   logging: { directory: "logs", maxFiles: 1, maxBytes: 1024 },
   approvals: { entries: [] },
 });
 
-const createContext = async (workspaceRoot: string | null, origin: string) => {
+const createContext = async (
+  workspaceRoot: string | null,
+  origin: string,
+  healthchecks?: AppConfig["healthchecks"],
+) => {
   const configDir = await createTempDir();
-  const config = createConfig(workspaceRoot, origin);
+  const config = createConfig(workspaceRoot, origin, healthchecks);
   const tokenStore = new TokenStore(configDir);
   await tokenStore.load();
   const pairingManager = new PairingManager(
@@ -68,6 +106,7 @@ const createContext = async (workspaceRoot: string | null, origin: string) => {
     config.jobs.maxConcurrent,
     config.jobs.timeoutSeconds,
   );
+  const healthcheckStore = new HealthcheckResultStore();
   const logger = pino({ enabled: false });
   const capabilities = { tools: {} };
   const ctx: DaemonContext = {
@@ -76,27 +115,66 @@ const createContext = async (workspaceRoot: string | null, origin: string) => {
     tokenStore,
     pairingManager,
     jobManager,
+    healthcheckStore,
     capabilities,
     logger,
     version: "0.1.0",
     build: undefined,
   };
-  return { ctx, app: createApp(ctx) };
+  const app = createApp(ctx);
+  const server = await createHttpServer(app);
+  const client = request(server);
+  return { ctx, app, server, client };
+};
+
+const waitForJob = async (
+  ctx: DaemonContext,
+  jobId: string,
+  timeoutMs = 5000,
+) => {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const job = ctx.jobManager.get(jobId);
+    if (job && job.state !== "queued" && job.state !== "running") {
+      return job.state;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+  throw new Error(`Job ${jobId} did not finish in time.`);
+};
+
+const setupHealthcheckRepo = async (workspaceRoot: string) => {
+  const repoDir = path.join(workspaceRoot, "repo");
+  await fs.mkdir(repoDir, { recursive: true });
+  await runGit(repoDir, ["init", "-b", "main"]);
+  await runGit(repoDir, ["config", "user.email", "test@example.com"]);
+  await runGit(repoDir, ["config", "user.name", "Test User"]);
+  await fs.writeFile(
+    path.join(repoDir, "README.md"),
+    "# Title\n\nHello world.",
+  );
+  await fs.writeFile(
+    path.join(repoDir, "package.json"),
+    JSON.stringify({ name: "repo", packageManager: "pnpm@8.0.0" }, null, 2),
+  );
+  await runGit(repoDir, ["add", "README.md", "package.json"]);
+  await runGit(repoDir, ["commit", "-m", "init"]);
+  return { repoPath: "repo" };
 };
 
 describe("Git Daemon API", () => {
   const origin = "http://localhost:5173";
 
   it("rejects missing Origin header", async () => {
-    const { app } = await createContext(null, origin);
-    const res = await request(app).get("/v1/meta").set("Host", "127.0.0.1");
+    const { client } = await createContext(null, origin);
+    const res = await client.get("/v1/meta").set("Host", "127.0.0.1");
     expect(res.status).toBe(403);
     expect(res.body.errorCode).toBe("origin_not_allowed");
   });
 
   it("returns meta for allowed origin", async () => {
-    const { app } = await createContext(null, origin);
-    const res = await request(app)
+    const { client } = await createContext(null, origin);
+    const res = await client
       .get("/v1/meta")
       .set("Origin", origin)
       .set("Host", "127.0.0.1");
@@ -106,8 +184,8 @@ describe("Git Daemon API", () => {
   });
 
   it("requires auth for protected routes", async () => {
-    const { app } = await createContext(null, origin);
-    const res = await request(app)
+    const { client } = await createContext(null, origin);
+    const res = await client
       .get("/v1/git/status")
       .query({ repoPath: "repo" })
       .set("Origin", origin)
@@ -117,10 +195,10 @@ describe("Git Daemon API", () => {
   });
 
   it("returns workspace_required when not configured", async () => {
-    const { app, ctx } = await createContext(null, origin);
+    const { client, ctx } = await createContext(null, origin);
     const { token } = await ctx.tokenStore.issueToken(origin, 30);
 
-    const res = await request(app)
+    const res = await client
       .get("/v1/git/status")
       .query({ repoPath: "repo" })
       .set("Origin", origin)
@@ -133,10 +211,10 @@ describe("Git Daemon API", () => {
 
   it("validates repoUrl on clone", async () => {
     const workspaceRoot = await createTempDir();
-    const { app, ctx } = await createContext(workspaceRoot, origin);
+    const { client, ctx } = await createContext(workspaceRoot, origin);
     const { token } = await ctx.tokenStore.issueToken(origin, 30);
 
-    const res = await request(app)
+    const res = await client
       .post("/v1/git/clone")
       .set("Origin", origin)
       .set("Host", "127.0.0.1")
@@ -150,10 +228,10 @@ describe("Git Daemon API", () => {
   it("lists branches including remotes by default", async () => {
     const workspaceRoot = await createTempDir();
     const { repoPath } = await setupRepoWithRemote(workspaceRoot);
-    const { app, ctx } = await createContext(workspaceRoot, origin);
+    const { client, ctx } = await createContext(workspaceRoot, origin);
     const { token } = await ctx.tokenStore.issueToken(origin, 30);
 
-    const res = await request(app)
+    const res = await client
       .get("/v1/git/branches")
       .query({ repoPath })
       .set("Origin", origin)
@@ -180,4 +258,133 @@ describe("Git Daemon API", () => {
     const originMain = branches.find((branch) => branch.name === "origin/main");
     expect(originMain?.type).toBe("remote");
   });
+
+  it("returns a UI-friendly status summary", async () => {
+    const workspaceRoot = await createTempDir();
+    const { repoPath } = await setupRepoWithRemote(workspaceRoot);
+    const repoDir = path.join(workspaceRoot, repoPath);
+    await fs.writeFile(path.join(repoDir, "scratch.txt"), "dirty");
+    const { client, ctx } = await createContext(workspaceRoot, origin);
+    const { token } = await ctx.tokenStore.issueToken(origin, 30);
+
+    const res = await client
+      .get("/v1/git/summary")
+      .query({ repoPath })
+      .set("Origin", origin)
+      .set("Host", "127.0.0.1")
+      .set("Authorization", `Bearer ${token}`);
+
+    expect(res.status).toBe(200);
+    expect(res.body.repoPath).toBe(repoPath);
+    expect(res.body.exists).toBe(true);
+    expect(res.body.branch).toBe("feature");
+    expect(res.body.upstream).toBe("origin/feature");
+    expect(res.body.ahead).toBe(0);
+    expect(res.body.behind).toBe(0);
+    expect(res.body.dirty).toBe(true);
+    expect(res.body.untracked).toBe(1);
+    expect(res.body.staged).toBe(0);
+    expect(res.body.unstaged).toBe(0);
+    expect(res.body.conflicts).toBe(0);
+    expect(res.body.detached).toBe(false);
+  });
+
+  it("returns exists false when summary repo is missing", async () => {
+    const workspaceRoot = await createTempDir();
+    const { client, ctx } = await createContext(workspaceRoot, origin);
+    const { token } = await ctx.tokenStore.issueToken(origin, 30);
+
+    const res = await client
+      .get("/v1/git/summary")
+      .query({ repoPath: "missing" })
+      .set("Origin", origin)
+      .set("Host", "127.0.0.1")
+      .set("Authorization", `Bearer ${token}`);
+
+    expect(res.status).toBe(200);
+    expect(res.body.exists).toBe(false);
+    expect(res.body.branch).toBe("");
+    expect(res.body.dirty).toBe(false);
+    expect(res.body.ahead).toBe(0);
+    expect(res.body.behind).toBe(0);
+  });
+
+  it("lists available healthchecks", async () => {
+    const workspaceRoot = await createTempDir();
+    const suitePath = path.resolve(
+      process.cwd(),
+      "healthchecks",
+      "example-suite",
+    );
+    const { client, ctx } = await createContext(workspaceRoot, origin, {
+      suites: [suitePath],
+      defaultSuiteId: "example-suite",
+    });
+    const { token } = await ctx.tokenStore.issueToken(origin, 30);
+
+    const res = await client
+      .get("/v1/healthchecks")
+      .set("Origin", origin)
+      .set("Host", "127.0.0.1")
+      .set("Authorization", `Bearer ${token}`);
+
+    expect(res.status).toBe(200);
+    const suiteIds = (res.body.suites as Array<{ id: string }>).map(
+      (suite) => suite.id,
+    );
+    expect(suiteIds).toContain("example-suite");
+    const suite = (
+      res.body.suites as Array<{
+        id: string;
+        checks: Array<{ id: string }>;
+      }>
+    ).find((item) => item.id === "example-suite");
+    expect(suite?.checks.map((check) => check.id)).toEqual(
+      expect.arrayContaining(["about-description", "package-manager"]),
+    );
+  });
+
+  it("runs healthchecks and returns results", async () => {
+    const workspaceRoot = await createTempDir();
+    const { repoPath } = await setupHealthcheckRepo(workspaceRoot);
+    const suitePath = path.resolve(
+      process.cwd(),
+      "healthchecks",
+      "example-suite",
+    );
+    const { client, ctx } = await createContext(workspaceRoot, origin, {
+      suites: [suitePath],
+      defaultSuiteId: "example-suite",
+    });
+    const { token } = await ctx.tokenStore.issueToken(origin, 30);
+
+    const runRes = await client
+      .post("/v1/healthchecks/run")
+      .set("Origin", origin)
+      .set("Host", "127.0.0.1")
+      .set("Authorization", `Bearer ${token}`)
+      .send({
+        repoPath,
+        repoInfo: { description: "Hello world." },
+        checks: [
+          { checkId: "about-description" },
+          { checkId: "package-manager" },
+        ],
+      });
+
+    expect(runRes.status).toBe(202);
+    const jobId = runRes.body.jobId as string;
+    await waitForJob(ctx, jobId);
+
+    const resultRes = await client
+      .get(`/v1/healthchecks/jobs/${jobId}/result`)
+      .set("Origin", origin)
+      .set("Host", "127.0.0.1")
+      .set("Authorization", `Bearer ${token}`);
+
+    expect(resultRes.status).toBe(200);
+    expect(resultRes.body.repoPath).toBe(repoPath);
+    expect(resultRes.body.status).toBe("pass-full");
+    expect(resultRes.body.checks).toHaveLength(2);
+  });
 });