import { mkdtempSync } from "node:fs";import { tmpdir } from "node:os";import { join } from "node:path";import { describe, expect, it } from "@effect/vitest";import { Effect } from "effect";import { makeGitArtifactStore } from "./git-artifact-store";import type { ArtifactStoreError } from "../seams/artifact-store";const run = <A, E>(effect: Effect.Effect<A, E>): Promise<A> => Effect.runPromise(effect);// ---------------------------------------------------------------------------// Finding 6 regression (git compare-and-swap): two commits built from the SAME// parent cannot both advance the branch. The ref update is a CAS against the// expected old value, so the second raced writer gets a typed conflict instead// of silently clobbering the first. This is deterministic (no timing race): we// force both to share a parent by committing them against a store whose head we// pin.// ---------------------------------------------------------------------------describe("git ArtifactStore ref CAS (Fix 6)", () => { it("two concurrent commits from one parent: one wins, the other typed-conflicts", async () => { const root = mkdtempSync(join(tmpdir(), "apps-cas-")); const storeA = makeGitArtifactStore({ root }); const scopeA = await run(storeA.forScope("s")); // Seed a parent so racers commit ON TOP of the same head. await run(scopeA.commit(new Map([["tools/base.ts", "// base"]]), "base")); // Many SEPARATE store instances over the SAME repo dir. The repo already // exists (seeded above), so opening each scope is a re-`init --bare` (a no-op // on an existing repo). Open them SEQUENTIALLY so the idempotent init doesn't // itself race, then race only the COMMITS (the ref-CAS is what's under test). const N = 12; const openedScopes: { commit: typeof scopeA.commit; log: typeof scopeA.log }[] = []; for (let i = 0; i < N; i++) { const store = makeGitArtifactStore({ root }); // eslint-disable-next-line no-await-in-loop openedScopes.push(await run(store.forScope("s"))); } const scopeB = openedScopes[0]; // Fire many concurrent commits, ALL built against the seeded base parent. const results = await Promise.allSettled( openedScopes.map((sc, i) => run(sc.commit(new Map([[`tools/c${i}.ts`, `// ${i}`]]), `c${i}`)), ), ); const fulfilled = results.filter((r) => r.status === "fulfilled").length; const rejected = results.filter((r) => r.status === "rejected"); // Any failure MUST be a typed conflict (never a silent clobber). for (const r of rejected) { const err = (r as PromiseRejectedResult).reason as ArtifactStoreError; expect(String(JSON.stringify(err))).toMatch(/conflict/i); } // No lost commits: the git log length equals base(1) + every commit that // reported success. Without the CAS, a raced writer clobbers the ref and an // earlier successful commit vanishes from history, making the log SHORTER // than base + fulfilled. The CAS guarantees every reported success is a real, // reachable, non-clobbering advance. const logEntries = await run(scopeB.log(1000)); expect(logEntries.length).toBe(1 + fulfilled); }, 60_000);});
import { mkdtempSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { describe, expect, it } from "@effect/vitest";
import { Effect } from "effect";
import { makeGitArtifactStore } from "./git-artifact-store";
import type { ArtifactStoreError } from "../seams/artifact-store";
const run = <A, E>(effect: Effect.Effect<A, E>): Promise<A> => Effect.runPromise(effect);
// ---------------------------------------------------------------------------
// Finding 6 regression (git compare-and-swap): two commits built from the SAME
// parent cannot both advance the branch. The ref update is a CAS against the
// expected old value, so the second raced writer gets a typed conflict instead
// of silently clobbering the first. This is deterministic (no timing race): we
// force both to share a parent by committing them against a store whose head we
// pin.
// ---------------------------------------------------------------------------
describe("git ArtifactStore ref CAS (Fix 6)", () => {
it("two concurrent commits from one parent: one wins, the other typed-conflicts", async () => {
const root = mkdtempSync(join(tmpdir(), "apps-cas-"));
const storeA = makeGitArtifactStore({ root });
const scopeA = await run(storeA.forScope("s"));
// Seed a parent so racers commit ON TOP of the same head.
await run(scopeA.commit(new Map([["tools/base.ts", "// base"]]), "base"));
// Many SEPARATE store instances over the SAME repo dir. The repo already
// exists (seeded above), so opening each scope is a re-`init --bare` (a no-op
// on an existing repo). Open them SEQUENTIALLY so the idempotent init doesn't
// itself race, then race only the COMMITS (the ref-CAS is what's under test).
const N = 12;
const openedScopes: { commit: typeof scopeA.commit; log: typeof scopeA.log }[] = [];
for (let i = 0; i < N; i++) {
const store = makeGitArtifactStore({ root });
// eslint-disable-next-line no-await-in-loop
openedScopes.push(await run(store.forScope("s")));
}
const scopeB = openedScopes[0];
// Fire many concurrent commits, ALL built against the seeded base parent.
const results = await Promise.allSettled(
openedScopes.map((sc, i) =>
run(sc.commit(new Map([[`tools/c${i}.ts`, `// ${i}`]]), `c${i}`)),
),
);
const fulfilled = results.filter((r) => r.status === "fulfilled").length;
const rejected = results.filter((r) => r.status === "rejected");
// Any failure MUST be a typed conflict (never a silent clobber).
for (const r of rejected) {
const err = (r as PromiseRejectedResult).reason as ArtifactStoreError;
expect(String(JSON.stringify(err))).toMatch(/conflict/i);
}
// No lost commits: the git log length equals base(1) + every commit that
// reported success. Without the CAS, a raced writer clobbers the ref and an
// earlier successful commit vanishes from history, making the log SHORTER
// than base + fulfilled. The CAS guarantees every reported success is a real,
// reachable, non-clobbering advance.
const logEntries = await run(scopeB.log(1000));
expect(logEntries.length).toBe(1 + fulfilled);
}, 60_000);
});