@fungi.computer/bonsai 0.0.0-stage → 0.1.0

package/test/merge-background.test.ts

@@ -0,0 +1,756 @@
+import * as z from "zod";
+import { DatabaseSync } from "node:sqlite";
+import { expect, it } from "vitest";
+import {
+  dropMaterial,
+  sqliteGitStepMaterial,
+} from "@fungi.computer/agar/git-steps";
+import { mergeJobSchema } from "../backend/merge.js";
+import { commitFiles } from "@fungi.computer/agar/git-commit";
+import { countingGit } from "@fungi.computer/agar/read-copy";
+import {
+  backgroundContext,
+  backgroundOriginKey,
+  sealBackgroundOrigin,
+  admitClaimedOrigin,
+  type BackgroundBinding,
+} from "@fungi.computer/puffball/background-replay";
+import { fromNodeSqlite } from "@fungi.computer/watchdog/node-sqlite";
+import { realGit } from "@fungi.computer/agar/test-kit/git";
+import {
+  refuseBackground,
+  backgroundRuntime,
+  registerBackgroundProjector,
+} from "../backend/background.js";
+import { appBackend } from "../backend/methods.js";
+import { gitStore } from "../backend/git.js";
+import { getRepoDetail } from "../backend/repository-copy.js";
+import { ensureBonsaiTables, BonsaiState } from "../backend/state.js";
+import {
+  changeRecord,
+  changeDetail,
+  checkRequestResult,
+} from "../shared/contract.js";
+import { fileContent, fileSaveResult } from "@fungi.computer/agar/roles/files";
+
+const testKey = backgroundOriginKey("bonsai-background-merge-test-key");
+const instanceId = "bonsai-test-instance";
+async function enqueueCaller(
+  context: ReturnType<typeof caller> & { idempotencyKey: string },
+  method = "changes.merge",
+) {
+  const origin = await sealBackgroundOrigin(await testKey, {
+    instanceId,
+    lane: `member:${context.actor.memberId}`,
+    method,
+  });
+  return backgroundContext(
+    context,
+    [],
+    { name: method, effect: "write" },
+    origin,
+  );
+}
+function replayBinding(
+  admitted: readonly string[] = ["changes.merge"],
+): BackgroundBinding {
+  return {
+    admit: async (origin) =>
+      admitClaimedOrigin(
+        await testKey,
+        {
+          instanceId,
+          lane: "member:Levi",
+          admitted,
+        },
+        origin,
+      ),
+  };
+}
+
+const author = { name: "Morel", email: "morel@test.invalid" };
+const caller = (name: string) => ({
+  actor: { kind: "member" as const, memberId: name },
+  computerId: null,
+  role: "owner" as const,
+});
+
+async function fixture() {
+  const provider = realGit();
+  const database = new DatabaseSync(":memory:");
+  const owner = fromNodeSqlite(database);
+  ensureBonsaiTables(owner.sql);
+  const lifetime = new AbortController();
+  const exchanges: { service: string; phase: string }[] = [];
+  const counted = countingGit(
+    {
+      ...provider.git,
+      exchange: async (repo, request) => {
+        exchanges.push({ service: request.service, phase: request.phase });
+        return provider.git.exchange(repo, request);
+      },
+    },
+    {
+      limit: 10_000,
+      signal: lifetime.signal,
+    },
+  );
+  const bonsai = {
+    state: new BonsaiState(owner.sql, owner.transactionSync),
+    store: gitStore(counted.git),
+    events: { emit: () => Promise.resolve() },
+  };
+  await provider.git.create("pond");
+  bonsai.state.registerRepo({
+    name: "pond",
+    description: null,
+    parent: null,
+    owner: null,
+  });
+  const base = await commitFiles(provider.git, {
+    repository: "pond",
+    branch: "main",
+    expectedHead: null,
+    author,
+    message: "Start",
+    changes: [
+      { path: "notes.txt", content: new TextEncoder().encode("Fish\n") },
+    ],
+  });
+  if (base.kind !== "committed") throw new Error("Fixture base did not commit");
+  const source = await commitFiles(provider.git, {
+    repository: "pond",
+    branch: "feature",
+    expectedHead: null,
+    startFrom: "main",
+    author,
+    message: "Add waves",
+    changes: [
+      { path: "waves.txt", content: new TextEncoder().encode("Waves\n") },
+    ],
+  });
+  if (source.kind !== "committed")
+    throw new Error("Fixture source did not commit");
+  await getRepoDetail(bonsai, "pond");
+  const open = async () =>
+    changeRecord.parse(
+      await appBackend.call(
+        "changes.open",
+        { repo: "pond", sourceRef: "feature" },
+        { bonsai },
+        caller("Morel"),
+      ),
+    );
+  const detail = async (number: number) =>
+    changeDetail.parse(
+      await appBackend.call(
+        "changes.get",
+        { repo: "pond", number },
+        { bonsai },
+        caller("Levi"),
+      ),
+    );
+  return {
+    bonsai,
+    provider,
+    counted,
+    exchanges,
+    base: base.commit,
+    source: source.commit,
+    open,
+    detail,
+    reopen() {
+      return {
+        ...bonsai,
+        state: new BonsaiState(owner.sql, owner.transactionSync),
+      };
+    },
+    close() {
+      lifetime.abort();
+      database.close();
+      provider.close();
+    },
+  };
+}
+
+it("accepts a member merge as Merging without changing Git in the click", async () => {
+  const f = await fixture();
+  try {
+    const row = await f.open();
+    await f.detail(row.number);
+    const before = f.counted.counts();
+    const result = await appBackend.call(
+      "changes.merge",
+      { repo: "pond", number: row.number, head: f.source },
+      { bonsai: f.bonsai },
+      await enqueueCaller({
+        ...caller("Levi"),
+        idempotencyKey: "background-merge-click",
+      }),
+    );
+    expect(result).toMatchObject({ kind: "merging" });
+    const pending = await f.detail(row.number);
+    expect(pending.change).toMatchObject({
+      state: "merging",
+      lease: { by: "Levi", head: f.source },
+    });
+    expect((f.counted.counts().exchange ?? 0) - (before.exchange ?? 0)).toBe(0);
+    expect(await f.provider.git.refs("pond")).toContainEqual({
+      name: "refs/heads/main",
+      hash: f.base,
+    });
+  } finally {
+    f.close();
+  }
+});
+
+it("rechecks failed rows on replay, refuses the merge and releases its lease without Git", async () => {
+  const f = await fixture();
+  try {
+    const row = await f.open();
+    await f.detail(row.number);
+    await appBackend.call(
+      "changes.merge",
+      { repo: "pond", number: row.number, head: f.source },
+      { bonsai: f.bonsai },
+      await enqueueCaller({
+        ...caller("Levi"),
+        idempotencyKey: "policy-change-click",
+      }),
+    );
+    const checker = {
+      actor: { kind: "agent" as const, agentId: "ci" },
+      computerId: null,
+    };
+    const requested = checkRequestResult.parse(
+      await appBackend.call(
+        "checks.request",
+        {
+          repo: "pond",
+          number: row.number,
+          head: f.source,
+          names: ["typecheck"],
+        },
+        { bonsai: f.bonsai },
+        checker,
+      ),
+    );
+    if (requested.kind !== "requested")
+      throw new Error("Fixture check not requested");
+    await appBackend.call(
+      "checks.report",
+      {
+        repo: "pond",
+        number: row.number,
+        head: f.source,
+        attemptId: requested.attemptId,
+        name: "typecheck",
+        status: "failed",
+      },
+      { bonsai: f.bonsai },
+      checker,
+    );
+    const before = f.counted.total();
+    expect(
+      await appBackend.call(
+        "sync",
+        {},
+        { bonsai: f.reopen(), env: { BACKGROUND: replayBinding() } },
+        { ...caller("Levi"), idempotencyKey: "replay-policy-1" },
+      ),
+    ).toEqual({ more: false });
+    expect(f.counted.total() - before).toBe(0);
+    expect((await f.detail(row.number)).change).toMatchObject({
+      state: "open",
+      lease: null,
+      mergeFailure: "access_changed",
+    });
+    expect(await f.provider.git.refs("pond")).toContainEqual({
+      name: "refs/heads/main",
+      hash: f.base,
+    });
+  } finally {
+    f.close();
+  }
+});
+
+it("reconstructs one merge step per replay without reporting an intermediate merge as complete", async () => {
+  const f = await fixture();
+  try {
+    const row = await f.open();
+    await f.detail(row.number);
+    await appBackend.call(
+      "changes.merge",
+      { repo: "pond", number: row.number, head: f.source },
+      { bonsai: f.bonsai },
+      await enqueueCaller({
+        ...caller("Levi"),
+        idempotencyKey: "step-merge-click",
+      }),
+    );
+    let more = true;
+    let frames = 0;
+    while (more && frames < 12) {
+      const bonsai = f.reopen();
+      const before = f.counted.counts().exchange ?? 0;
+      const result = await appBackend.call(
+        "sync",
+        {},
+        { bonsai, env: { BACKGROUND: replayBinding() } },
+        { ...caller("Levi"), idempotencyKey: `step-replay-${String(frames)}` },
+      );
+      expect((f.counted.counts().exchange ?? 0) - before).toBeLessThanOrEqual(
+        1,
+      );
+      more = z.strictObject({ more: z.boolean() }).parse(result).more;
+      if (!more)
+        expect(f.exchanges.at(-1)).not.toEqual({
+          service: "receive-pack",
+          phase: "exchange",
+        });
+      const current = bonsai.state.requireChange("pond", row.number);
+      if (more) {
+        const readStart = f.counted.total();
+        expect((await f.detail(row.number)).change.state).toBe("merging");
+        expect(f.counted.total() - readStart).toBe(0);
+      }
+      if (more)
+        expect(current).toMatchObject({
+          state: "merging",
+          lease: { head: f.source },
+          mergedCommit: null,
+        });
+      else
+        expect(current).toMatchObject({
+          state: "merged",
+          lease: null,
+          mergedBy: "Levi",
+        });
+      frames++;
+    }
+    expect(more).toBe(false);
+    expect(frames).toBeGreaterThan(1);
+    expect(await f.provider.git.refs("pond")).toContainEqual({
+      name: "refs/heads/main",
+      hash: f.bonsai.state.requireChange("pond", row.number).mergedCommit,
+    });
+  } finally {
+    f.close();
+  }
+});
+
+it("settles an access-changed merge lane without Git and preserves another member's pending work", async () => {
+  const f = await fixture();
+  try {
+    const row = await f.open();
+    await f.detail(row.number);
+    await appBackend.call(
+      "changes.merge",
+      { repo: "pond", number: row.number, head: f.source },
+      { bonsai: f.bonsai },
+      await enqueueCaller({
+        ...caller("Levi"),
+        idempotencyKey: "refused-merge-click",
+      }),
+    );
+    await appBackend.call(
+      "files.save",
+      {
+        repo: "pond",
+        branch: "main",
+        path: "private.txt",
+        text: "Retained",
+        baseCommit: f.base,
+        baseBlob: null,
+        revision: null,
+      },
+      { bonsai: f.bonsai },
+      await enqueueCaller(
+        { ...caller("Riley"), idempotencyKey: "other-private-save" },
+        "files.save",
+      ),
+    );
+    const bonsai = f.reopen();
+    const before = f.counted.total();
+    await refuseBackground(bonsai, {
+      lane: "member:Levi",
+      code: "access_changed",
+    });
+    await refuseBackground(bonsai, {
+      lane: "member:Levi",
+      code: "access_changed",
+    });
+    expect(f.counted.total() - before).toBe(0);
+    expect(bonsai.state.requireChange("pond", row.number)).toMatchObject({
+      state: "open",
+      lease: null,
+      mergeFailure: "access_changed",
+    });
+    expect(bonsai.state.fileEdits.hasPending("member:Riley")).toBe(true);
+  } finally {
+    f.close();
+  }
+});
+
+it("recovers a checkpointed step after settlement failure without repeating its Git exchange", async () => {
+  const f = await fixture();
+  try {
+    const row = await f.open();
+    await f.detail(row.number);
+    await appBackend.call(
+      "changes.merge",
+      { repo: "pond", number: row.number, head: f.source },
+      { bonsai: f.bonsai },
+      await enqueueCaller({
+        ...caller("Levi"),
+        idempotencyKey: "recovery-merge-click",
+      }),
+    );
+    const runtime = await backgroundRuntime(
+      f.bonsai,
+      caller("Levi"),
+      new AbortController().signal,
+      replayBinding(),
+    );
+    registerBackgroundProjector(f.bonsai, "merge", (transition) => {
+      if (transition.settled?.outcome === "completed")
+        throw new Error("Storage settlement interrupted");
+    });
+    const before = f.counted.counts().exchange ?? 0;
+    await expect(runtime.tickConcurrent()).rejects.toThrow();
+    expect((f.counted.counts().exchange ?? 0) - before).toBe(1);
+    const recoveryStart = f.counted.counts().exchange ?? 0;
+    expect(
+      await appBackend.call(
+        "sync",
+        {},
+        { bonsai: f.reopen(), env: { BACKGROUND: replayBinding() } },
+        { ...caller("Levi"), idempotencyKey: "recover-checkpoint" },
+      ),
+    ).toEqual({ more: true });
+    expect((f.counted.counts().exchange ?? 0) - recoveryStart).toBe(0);
+    expect(f.bonsai.state.requireChange("pond", row.number)).toMatchObject({
+      state: "merging",
+      lease: { head: f.source },
+    });
+    let more = true;
+    for (let frame = 0; more && frame < 12; frame++) {
+      const start = f.counted.counts().exchange ?? 0;
+      const result = await appBackend.call(
+        "sync",
+        {},
+        { bonsai: f.reopen(), env: { BACKGROUND: replayBinding() } },
+        { ...caller("Levi"), idempotencyKey: `recovery-step-${String(frame)}` },
+      );
+      expect((f.counted.counts().exchange ?? 0) - start).toBeLessThanOrEqual(1);
+      more = z.strictObject({ more: z.boolean() }).parse(result).more;
+    }
+    expect(more).toBe(false);
+    expect(f.bonsai.state.requireChange("pond", row.number)).toMatchObject({
+      state: "merged",
+      lease: null,
+    });
+  } finally {
+    f.close();
+  }
+});
+
+it("leaves a queued merge unclaimed on foreground sync and refuses a freshly withdrawn origin", async () => {
+  const f = await fixture();
+  try {
+    const row = await f.open();
+    await f.detail(row.number);
+    await appBackend.call(
+      "changes.merge",
+      { repo: "pond", number: row.number, head: f.source },
+      { bonsai: f.bonsai },
+      await enqueueCaller({
+        ...caller("Levi"),
+        idempotencyKey: "origin-withdrawal",
+      }),
+    );
+    const before = f.counted.total();
+    expect(
+      await appBackend.call("sync", {}, { bonsai: f.reopen() }, caller("Levi")),
+    ).toEqual({ more: false });
+    expect(f.bonsai.state.requireChange("pond", row.number).state).toBe(
+      "merging",
+    );
+    expect(
+      await appBackend.call(
+        "sync",
+        {},
+        { bonsai: f.reopen(), env: { BACKGROUND: replayBinding([]) } },
+        caller("Levi"),
+      ),
+    ).toEqual({ more: false });
+    expect(f.counted.total() - before).toBe(0);
+    expect(f.bonsai.state.requireChange("pond", row.number)).toMatchObject({
+      state: "open",
+      lease: null,
+      mergeFailure: "access_changed",
+    });
+  } finally {
+    f.close();
+  }
+});
+
+it("settles missing immutable step material as a permanent merge failure without retrying Git", async () => {
+  const f = await fixture();
+  try {
+    const row = await f.open();
+    await f.detail(row.number);
+    await appBackend.call(
+      "changes.merge",
+      { repo: "pond", number: row.number, head: f.source },
+      { bonsai: f.bonsai },
+      await enqueueCaller({
+        ...caller("Levi"),
+        idempotencyKey: "material-unavailable",
+      }),
+    );
+    const lease = f.bonsai.state.requireChange("pond", row.number).lease;
+    if (lease === null) throw new Error("Missing merge lease");
+    for (let frame = 0; frame < 3; frame++)
+      await appBackend.call(
+        "sync",
+        {},
+        { bonsai: f.reopen(), env: { BACKGROUND: replayBinding() } },
+        caller("Levi"),
+      );
+    const runtime = await backgroundRuntime(
+      f.reopen(),
+      caller("Levi"),
+      new AbortController().signal,
+      replayBinding(),
+    );
+    const head = await runtime.readQueueHead(`merge:${lease.id}`);
+    if (head.state === "idle") throw new Error("Missing step successor");
+    const stored = await runtime.read(head.jobId);
+    if (stored.status !== "found") throw new Error("Missing step job");
+    const payload = mergeJobSchema.parse(stored.job.payload);
+    if (payload.checkpoint === null)
+      throw new Error("Missing persisted checkpoint");
+    expect(payload.checkpoint.phase).toBe("push");
+    await dropMaterial(
+      payload.checkpoint,
+      sqliteGitStepMaterial(f.bonsai.state.backgroundOwner.sql),
+    );
+    const before = f.counted.total();
+    expect(
+      await appBackend.call(
+        "sync",
+        {},
+        { bonsai: f.reopen(), env: { BACKGROUND: replayBinding() } },
+        caller("Levi"),
+      ),
+    ).toEqual({ more: false });
+    expect(f.counted.total() - before).toBe(0);
+    const terminal = await runtime.read(head.jobId);
+    expect(terminal).toMatchObject({
+      status: "found",
+      job: {
+        state: "settled",
+        outcome: "failed",
+        failureReason: "sync_failed",
+      },
+    });
+    expect(f.bonsai.state.requireChange("pond", row.number)).toMatchObject({
+      state: "open",
+      lease: null,
+      mergeFailure: "sync_failed",
+    });
+    expect(
+      await appBackend.call(
+        "sync",
+        {},
+        { bonsai: f.reopen(), env: { BACKGROUND: replayBinding() } },
+        caller("Levi"),
+      ),
+    ).toEqual({ more: false });
+    expect(f.counted.total() - before).toBe(0);
+  } finally {
+    f.close();
+  }
+});
+
+it("composes queued file and merge stages through one fresh replay claim per frame", async () => {
+  const f = await fixture();
+  try {
+    const draft = await commitFiles(f.provider.git, {
+      repository: "pond",
+      branch: "draft",
+      expectedHead: null,
+      startFrom: "main",
+      author,
+      message: "Start draft",
+      changes: [
+        { path: "draft.txt", content: new TextEncoder().encode("Draft\n") },
+      ],
+    });
+    if (draft.kind !== "committed")
+      throw new Error("Draft fixture did not commit");
+    f.bonsai.state.repositoryCopies.stale("pond");
+    await getRepoDetail(f.bonsai, "pond");
+    const row = await f.open();
+    await f.detail(row.number);
+    const baseline = fileContent.parse(
+      await appBackend.call(
+        "files.read",
+        { repo: "pond", ref: "draft", path: "notes.txt" },
+        { bonsai: f.bonsai },
+        caller("Levi"),
+      ),
+    );
+    const saved = fileSaveResult.parse(
+      await appBackend.call(
+        "files.save",
+        {
+          repo: "pond",
+          branch: "draft",
+          path: "notes.txt",
+          text: "Private draft update\n",
+          baseCommit: baseline.commit,
+          baseBlob: baseline.blob,
+          revision: null,
+        },
+        { bonsai: f.bonsai },
+        await enqueueCaller(
+          { ...caller("Levi"), idempotencyKey: "mixed-file-click" },
+          "files.save",
+        ),
+      ),
+    );
+    expect(saved).toMatchObject({ kind: "saved", state: "pending" });
+    await appBackend.call(
+      "changes.merge",
+      { repo: "pond", number: row.number, head: f.source },
+      { bonsai: f.bonsai },
+      await enqueueCaller({
+        ...caller("Levi"),
+        idempotencyKey: "mixed-merge-click",
+      }),
+    );
+    let more = true;
+    let frames = 0;
+    while (more && frames < 20) {
+      const admitted = replayBinding(["files.save", "changes.merge"]);
+      let claims = 0;
+      const background = {
+        admit: (origin: Parameters<typeof admitted.admit>[0]) => {
+          claims++;
+          return admitted.admit(origin);
+        },
+      };
+      const before = f.counted.counts().exchange ?? 0;
+      const result = await appBackend.call(
+        "sync",
+        {},
+        { bonsai: f.reopen(), env: { BACKGROUND: background } },
+        { ...caller("Levi"), idempotencyKey: `mixed-frame-${String(frames)}` },
+      );
+      expect(claims).toBeLessThanOrEqual(1);
+      expect((f.counted.counts().exchange ?? 0) - before).toBeLessThanOrEqual(
+        1,
+      );
+      more = z.strictObject({ more: z.boolean() }).parse(result).more;
+      frames++;
+    }
+    expect(more).toBe(false);
+    expect(frames).toBeGreaterThan(5);
+    expect(f.bonsai.state.requireChange("pond", row.number)).toMatchObject({
+      state: "merged",
+      lease: null,
+    });
+    expect(
+      fileContent.parse(
+        await appBackend.call(
+          "files.read",
+          { repo: "pond", ref: "draft", path: "notes.txt" },
+          { bonsai: f.reopen() },
+          caller("Levi"),
+        ),
+      ),
+    ).toMatchObject({ text: "Private draft update\n" });
+  } finally {
+    f.close();
+  }
+});
+
+it("keeps an active claim alive across two public sync frames while admission is pending", async () => {
+  const f = await fixture();
+  const entered = Promise.withResolvers<undefined>();
+  const release = Promise.withResolvers<undefined>();
+  let first:
+    | Promise<{ ok: true; value: unknown } | { ok: false; error: unknown }>
+    | undefined;
+  try {
+    const row = await f.open();
+    await f.detail(row.number);
+    await appBackend.call(
+      "changes.merge",
+      { repo: "pond", number: row.number, head: f.source },
+      { bonsai: f.bonsai },
+      await enqueueCaller({
+        ...caller("Levi"),
+        idempotencyKey: "live-claim-click",
+      }),
+    );
+    const realAdmission = replayBinding();
+    const background = {
+      admit: async (origin: Parameters<typeof realAdmission.admit>[0]) => {
+        entered.resolve(undefined);
+        await release.promise;
+        return realAdmission.admit(origin);
+      },
+    };
+    first = appBackend
+      .call(
+        "sync",
+        {},
+        { bonsai: f.bonsai, env: { BACKGROUND: background } },
+        { ...caller("Levi"), idempotencyKey: "live-frame-A" },
+      )
+      .then(
+        (value) => ({ ok: true as const, value }),
+        (error: unknown) => ({ ok: false as const, error }),
+      );
+    await entered.promise;
+    let secondAdmissions = 0;
+    const secondBackground = {
+      admit: (origin: Parameters<typeof realAdmission.admit>[0]) => {
+        secondAdmissions++;
+        return realAdmission.admit(origin);
+      },
+    };
+    const before = f.counted.total();
+    expect(
+      await appBackend.call(
+        "sync",
+        {},
+        { bonsai: f.bonsai, env: { BACKGROUND: secondBackground } },
+        { ...caller("Levi"), idempotencyKey: "live-frame-B" },
+      ),
+    ).toEqual({ more: true });
+    expect(secondAdmissions).toBe(0);
+    expect(f.counted.total() - before).toBe(0);
+    release.resolve(undefined);
+    expect(await first).toEqual({ ok: true, value: { more: true } });
+    const stepStart = f.counted.counts().exchange ?? 0;
+    expect(
+      await appBackend.call(
+        "sync",
+        {},
+        { bonsai: f.bonsai, env: { BACKGROUND: replayBinding() } },
+        { ...caller("Levi"), idempotencyKey: "after-live-frame" },
+      ),
+    ).toEqual({ more: true });
+    expect((f.counted.counts().exchange ?? 0) - stepStart).toBeLessThanOrEqual(
+      1,
+    );
+  } finally {
+    release.resolve(undefined);
+    if (first !== undefined) await first;
+    f.close();
+  }
+});