@fungi.computer/bonsai 0.0.0-stage → 0.1.0

package/test/merge-repro.test.ts

@@ -0,0 +1,561 @@
+import * as z from "zod";
+import { DatabaseSync } from "node:sqlite";
+import { expect, it } from "vitest";
+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 { appBackend } from "../backend/methods.js";
+import { settleMerge, recoverExpiredLease } from "../backend/merge.js";
+import { gitStore } from "../backend/git.js";
+import { getRepoDetail } from "../backend/repository-copy.js";
+import { ensureBonsaiTables, BonsaiState } from "../backend/state.js";
+import { changeRecord, changeDetail } from "../shared/contract.js";
+
+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");
+  const source2 = await commitFiles(provider.git, {
+    repository: "pond",
+    branch: "feature2",
+    expectedHead: null,
+    startFrom: "main",
+    author,
+    message: "Add fins",
+    changes: [
+      { path: "fins.txt", content: new TextEncoder().encode("Fins\n") },
+    ],
+  });
+  if (source2.kind !== "committed") throw new Error("source2");
+  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,
+    source2: source2.commit,
+    open,
+    detail,
+    reopen() {
+      return {
+        ...bonsai,
+        state: new BonsaiState(owner.sql, owner.transactionSync),
+      };
+    },
+    close() {
+      lifetime.abort();
+      database.close();
+      provider.close();
+    },
+  };
+}
+
+async function drain(f: Awaited<ReturnType<typeof fixture>>, tag: string) {
+  let more = true;
+  let frames = 0;
+  while (more && frames < 24) {
+    const result = await appBackend.call(
+      "sync",
+      {},
+      { bonsai: f.reopen(), env: { BACKGROUND: replayBinding() } },
+      { ...caller("Levi"), idempotencyKey: `${tag}-${String(frames)}` },
+    );
+    more = z.strictObject({ more: z.boolean() }).parse(result).more;
+    frames++;
+  }
+  return { more, frames };
+}
+
+/**
+ * Drains a queued merge while a competing writer keeps moving the target
+ * branch out from under it, forcing every attempt's push to see a stale
+ * target CAS and exhaust the bounded retry.
+ */
+async function drainRacing(
+  f: Awaited<ReturnType<typeof fixture>>,
+  tag: string,
+  startHead: string,
+) {
+  let more = true;
+  let frames = 0;
+  let mainHead = startHead;
+  while (more && frames < 40) {
+    const race = await commitFiles(f.provider.git, {
+      repository: "pond",
+      branch: "main",
+      expectedHead: mainHead,
+      author,
+      message: `Race ${String(frames)}`,
+      changes: [
+        {
+          path: "race.txt",
+          content: new TextEncoder().encode(`race ${String(frames)}\n`),
+        },
+      ],
+    });
+    if (race.kind !== "committed") throw new Error("Race commit did not land");
+    mainHead = race.commit;
+    const result = await appBackend.call(
+      "sync",
+      {},
+      { bonsai: f.reopen(), env: { BACKGROUND: replayBinding() } },
+      { ...caller("Levi"), idempotencyKey: `${tag}-${String(frames)}` },
+    );
+    more = z.strictObject({ more: z.boolean() }).parse(result).more;
+    frames++;
+  }
+  return { more, frames };
+}
+
+async function openSecond(f: Awaited<ReturnType<typeof fixture>>) {
+  const row = changeRecord.parse(
+    await appBackend.call(
+      "changes.open",
+      { repo: "pond", sourceRef: "feature2" },
+      { bonsai: f.bonsai },
+      caller("Morel"),
+    ),
+  );
+  return { row, head: f.source2 };
+}
+
+const merge = async (
+  f: Awaited<ReturnType<typeof fixture>>,
+  number: number,
+  head: string,
+  key: string,
+) =>
+  appBackend.call(
+    "changes.merge",
+    { repo: "pond", number, head },
+    { bonsai: f.bonsai },
+    await enqueueCaller({ ...caller("Levi"), idempotencyKey: key }),
+  );
+
+it("settles a second same-member merge after the first one already settled", async () => {
+  const f = await fixture();
+  try {
+    const first = await f.open();
+    const second = await openSecond(f);
+    await f.detail(first.number);
+    await f.detail(second.row.number);
+    expect(await merge(f, first.number, f.source, "m1")).toMatchObject({
+      kind: "merging",
+    });
+    await drain(f, "a");
+    await f.detail(second.row.number);
+    await merge(f, second.row.number, second.head, "m2");
+    await drain(f, "b");
+    const after = f.bonsai.state.requireChange("pond", second.row.number);
+    expect(after.state).toBe("merged");
+  } finally {
+    f.close();
+  }
+});
+
+it("records mergeFailure sync_failed when a background merge exhausts its stale-CAS retries", async () => {
+  const f = await fixture();
+  try {
+    const first = await f.open();
+    await f.detail(first.number);
+    expect(await merge(f, first.number, f.source, "race1")).toMatchObject({
+      kind: "merging",
+    });
+    await drainRacing(f, "race", f.base);
+    const after = f.bonsai.state.requireChange("pond", first.number);
+    expect(after.state).toBe("open");
+    expect(after.lease).toBeNull();
+    expect(after.mergeFailure).toBe("sync_failed");
+  } finally {
+    f.close();
+  }
+});
+
+/**
+ * `settleMerge`'s own ownership/head/target races are only reachable in a
+ * real end-to-end run through a window far narrower than this single-
+ * threaded test runner can land a competing write into (the Watchdog's own
+ * per-frame policy gate re-checks the row's head on every continuation, so
+ * any black-box write lands either before it -- refusing the job outright,
+ * honestly, as "access_changed" -- or not at all). Driving `settleMerge`
+ * directly tests the exact race it resolves without fighting that gate.
+ */
+it("settleMerge names the commit that actually landed when the row's head moved before it settled", async () => {
+  const f = await fixture();
+  try {
+    const row = await f.open();
+    const leaseId = "lease-case-a";
+    const leased = f.bonsai.state.reviseChange(
+      {
+        ...row,
+        state: "merging",
+        lease: { id: leaseId, by: "Levi", head: row.head, at: Date.now() },
+      },
+      row.revision,
+    );
+    // The author pushed a new commit to the source while this lease's
+    // merge was in flight: the stored row's head no longer matches what
+    // the lease (and the Git work it drove) was actually merging. The
+    // merge still landed, though, so this isn't a sync failure -- it's
+    // an honest "merged, but for a head this Change no longer shows".
+    f.bonsai.state.reviseChange(
+      { ...leased, head: f.source2 },
+      leased.revision,
+    );
+    settleMerge(
+      f.bonsai,
+      { name: "Levi", kind: "human" },
+      leased,
+      { repo: "pond", number: row.number, head: row.head },
+      "unit-case-a",
+      JSON.stringify({ case: "a" }),
+      "https://source.invalid",
+      "https://target.invalid",
+      { kind: "merged", before: f.base, after: f.source },
+      true,
+    );
+    const after = f.bonsai.state.requireChange("pond", row.number);
+    expect(after.state).toBe("open");
+    expect(after.mergeFailure).toBe("head_moved");
+    expect(after.mergedCommit).toBe(f.source);
+    expect(after.mergedBy).toBe("Levi");
+  } finally {
+    f.close();
+  }
+});
+
+it("settleMerge records a real conflict even when the row's cached target has raced to a third value", async () => {
+  const f = await fixture();
+  try {
+    const row = await f.open();
+    const leaseId = "lease-case-b";
+    const leased = f.bonsai.state.reviseChange(
+      {
+        ...row,
+        state: "merging",
+        lease: { id: leaseId, by: "Levi", head: row.head, at: Date.now() },
+      },
+      row.revision,
+    );
+    // Some other concurrent write raced the row's cached target to a
+    // third value, independent of Git itself, while this lease's merge
+    // ran -- exactly what previously made settleMerge drop the conflict
+    // it had just found, since neither side of its target guard matched.
+    f.bonsai.state.reviseChange(
+      { ...leased, target: "0".repeat(40) },
+      leased.revision,
+    );
+    settleMerge(
+      f.bonsai,
+      { name: "Levi", kind: "human" },
+      leased,
+      { repo: "pond", number: row.number, head: row.head },
+      "unit-case-b",
+      JSON.stringify({ case: "b" }),
+      "https://source.invalid",
+      "https://target.invalid",
+      { kind: "conflict", head: f.base, paths: ["notes.txt"] },
+      true,
+    );
+    const after = f.bonsai.state.requireChange("pond", row.number);
+    expect(after.state).toBe("open");
+    expect(after.conflict).toMatchObject({
+      head: row.head,
+      paths: ["notes.txt"],
+    });
+    // The raced bookkeeping field is left alone: it matched neither what
+    // this attempt proposed nor what it found, so overwriting it would
+    // have been a guess, not a fact.
+    expect(after.target).toBe("0".repeat(40));
+  } finally {
+    f.close();
+  }
+});
+
+it("settleMerge records head_moved, not a conflict, when the conflicting head is already superseded", async () => {
+  const f = await fixture();
+  try {
+    const row = await f.open();
+    const leaseId = "lease-case-a-conflict";
+    const leased = f.bonsai.state.reviseChange(
+      {
+        ...row,
+        state: "merging",
+        lease: { id: leaseId, by: "Levi", head: row.head, at: Date.now() },
+      },
+      row.revision,
+    );
+    // The author pushed a new commit to the source while this lease's
+    // conflicting merge attempt was in flight. The conflict it found was
+    // against a head this Change no longer shows, so recording it as
+    // this Change's current conflict would be stale and wrong.
+    f.bonsai.state.reviseChange(
+      { ...leased, head: f.source2 },
+      leased.revision,
+    );
+    settleMerge(
+      f.bonsai,
+      { name: "Levi", kind: "human" },
+      leased,
+      { repo: "pond", number: row.number, head: row.head },
+      "unit-case-a-conflict",
+      JSON.stringify({ case: "a-conflict" }),
+      "https://source.invalid",
+      "https://target.invalid",
+      { kind: "conflict", head: f.base, paths: ["notes.txt"] },
+      true,
+    );
+    const after = f.bonsai.state.requireChange("pond", row.number);
+    expect(after.state).toBe("open");
+    expect(after.conflict).toBeNull();
+    expect(after.mergeFailure).toBe("head_moved");
+  } finally {
+    f.close();
+  }
+});
+
+it("settleMerge records head_moved, never sync_failed, for a source Git itself found moved", async () => {
+  const f = await fixture();
+  try {
+    const row = await f.open();
+    const leaseId = "lease-source-moved";
+    const leased = f.bonsai.state.reviseChange(
+      {
+        ...row,
+        state: "merging",
+        lease: { id: leaseId, by: "Levi", head: row.head, at: Date.now() },
+      },
+      row.revision,
+    );
+    // Git's own fetch found the source branch had moved; the row's own
+    // head field hasn't caught up yet, but this is still the author's
+    // work overtaking the attempt, not a sync problem with the target.
+    settleMerge(
+      f.bonsai,
+      { name: "Levi", kind: "human" },
+      leased,
+      { repo: "pond", number: row.number, head: row.head },
+      "unit-source-moved",
+      JSON.stringify({ case: "source-moved" }),
+      "https://source.invalid",
+      "https://target.invalid",
+      { kind: "source-moved", head: f.source2 },
+      true,
+    );
+    const after = f.bonsai.state.requireChange("pond", row.number);
+    expect(after.state).toBe("open");
+    expect(after.mergeFailure).toBe("head_moved");
+  } finally {
+    f.close();
+  }
+});
+
+it("settles both merges when two same-member merges overlap on one lane", async () => {
+  const f = await fixture();
+  try {
+    const first = await f.open();
+    const second = await openSecond(f);
+    await f.detail(first.number);
+    await f.detail(second.row.number);
+    await merge(f, first.number, f.source, "o1");
+    await appBackend.call(
+      "sync",
+      {},
+      { bonsai: f.reopen(), env: { BACKGROUND: replayBinding() } },
+      { ...caller("Levi"), idempotencyKey: "o-pre" },
+    );
+    await merge(f, second.row.number, second.head, "o2");
+    await drain(f, "o");
+    const a = f.bonsai.state.requireChange("pond", first.number);
+    const b = f.bonsai.state.requireChange("pond", second.row.number);
+    expect(a.state).toBe("merged");
+    expect(b.state).toBe("merged");
+  } finally {
+    f.close();
+  }
+});
+
+it("recoverExpiredLease records a typed failure instead of reopening a simply-expired lease silently", async () => {
+  const f = await fixture();
+  try {
+    const row = await f.open();
+    const leased = f.bonsai.state.reviseChange(
+      {
+        ...row,
+        state: "merging",
+        lease: {
+          id: "lease-expired",
+          by: "Levi",
+          head: row.head,
+          at: Date.now() - 121_000,
+        },
+      },
+      row.revision,
+    );
+    // Nothing ever landed for this lease (no merge ran), and the head
+    // it was merging is still current: this is an ordinary expiry, not
+    // a head move, so it settles as an honest sync failure.
+    const recovered = await recoverExpiredLease(f.bonsai, leased);
+    expect(recovered.state).toBe("open");
+    expect(recovered.lease).toBeNull();
+    expect(recovered.mergedCommit).toBeNull();
+    expect(recovered.mergeFailure).toBe("sync_failed");
+  } finally {
+    f.close();
+  }
+});
+
+it("recoverExpiredLease records head_moved instead of reopening silently when the source also moved before it expired", async () => {
+  const f = await fixture();
+  try {
+    const row = await f.open();
+    const leased = f.bonsai.state.reviseChange(
+      {
+        ...row,
+        state: "merging",
+        lease: {
+          id: "lease-expired-moved",
+          by: "Levi",
+          head: row.head,
+          at: Date.now() - 121_000,
+        },
+      },
+      row.revision,
+    );
+    // The author pushed a new commit to the source while this lease sat
+    // expired and unresolved: nothing it was merging is current anymore.
+    const moved = f.bonsai.state.reviseChange(
+      { ...leased, head: f.source2 },
+      leased.revision,
+    );
+    const recovered = await recoverExpiredLease(f.bonsai, moved);
+    expect(recovered.state).toBe("open");
+    expect(recovered.lease).toBeNull();
+    expect(recovered.mergedCommit).toBeNull();
+    expect(recovered.mergeFailure).toBe("head_moved");
+  } finally {
+    f.close();
+  }
+});