738 lines
47 KiB
TypeScript
738 lines
47 KiB
TypeScript
import { afterAll, afterEach, describe, expect, it, vi } from "vitest";
|
|
import { randomUUID } from "node:crypto";
|
|
import { Prisma } from "@prisma/client";
|
|
import { prisma } from "../src/db/prisma.js";
|
|
import { configureAutonomy, getAutonomyState, importAutonomyRoadmap, reportAutonomyWork } from "../src/repositories/autonomyRepository.js";
|
|
import { claimAutonomyWork } from "../src/services/autonomyRuntimeControl.js";
|
|
import { createOrResumeAutonomyDelivery } from "../src/services/autonomyDelivery.js";
|
|
import { createFeatureDelivery, getFeatureDelivery, openFeatureDeliveryPullRequest, recordFeatureDeliveryActionValidation, recordFeatureDeliveryProgress, startFeatureDelivery } from "../src/repositories/featureDeliveryRepository.js";
|
|
import { refreshDeliveryFromGitea } from "../src/services/deliveryReconciliation.js";
|
|
import { createProject } from "../src/repositories/projectsRepository.js";
|
|
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
|
|
import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
|
|
import { createProjectBrainMcpServer } from "../src/mcp/server.js";
|
|
import { loadEnv } from "../src/config/env.js";
|
|
import { GiteaApiError, GiteaClient } from "../src/integrations/gitea/client.js";
|
|
import { claimReadyWork, getProjectWorkGraph, reclaimExpiredWork, recordWorkCompletion, syncProjectWorkGraph, updateWorkDependencies } from "../src/services/workGraph.js";
|
|
|
|
const databaseUrl = process.env.TEST_DATABASE_URL;
|
|
if (databaseUrl) process.env.DATABASE_URL = databaseUrl;
|
|
const databaseDescribe = databaseUrl ? describe : describe.skip;
|
|
const slugs: string[] = [];
|
|
|
|
const createWorkGraphProject = async (markdown: string) => {
|
|
const slug = `workgraph-${randomUUID()}`;
|
|
slugs.push(slug);
|
|
await createProject({ id: slug, name: "Work graph concurrency proof", description: "Isolated database regression" });
|
|
await configureAutonomy(slug, { enabled: true, autoBrainstorm: false }, "database-test");
|
|
await importAutonomyRoadmap(slug, { markdown }, "database-test");
|
|
const project = await prisma.project.findUniqueOrThrow({ where: { slug } });
|
|
const graph = await getProjectWorkGraph(slug);
|
|
return { slug, project, graph };
|
|
};
|
|
|
|
const nodeByTitle = (graph: Awaited<ReturnType<typeof getProjectWorkGraph>>, title: string) => {
|
|
const node = graph.nodes.find((candidate) => candidate.title === title);
|
|
if (!node) throw new Error(`Missing work graph fixture node '${title}'.`);
|
|
return node;
|
|
};
|
|
|
|
const setAutonomyDependencies = async (projectId: string, slug: string, title: string, dependsOnTitles: string[]) => {
|
|
const state = await getAutonomyState(slug);
|
|
const items = state.roadmap?.phases.flatMap((phase) => phase.items) ?? [];
|
|
const target = items.find((item) => item.title === title);
|
|
if (!target) throw new Error(`Missing autonomy fixture item '${title}'.`);
|
|
target.dependsOn = dependsOnTitles.map((dependencyTitle) => {
|
|
const dependency = items.find((item) => item.title === dependencyTitle);
|
|
if (!dependency) throw new Error(`Missing autonomy fixture dependency '${dependencyTitle}'.`);
|
|
return dependency.id;
|
|
});
|
|
const workspace = await prisma.workspaceState.findUniqueOrThrow({ where: { projectId }, select: { notesJson: true } });
|
|
const notes = typeof workspace.notesJson === "object" && workspace.notesJson !== null && !Array.isArray(workspace.notesJson) ? workspace.notesJson : {};
|
|
await prisma.workspaceState.update({ where: { projectId }, data: { notesJson: { ...notes, autonomy: state } as Prisma.InputJsonValue } });
|
|
};
|
|
|
|
const setAutonomyPriority = async (projectId: string, slug: string, title: string, priority: number) => {
|
|
const state = await getAutonomyState(slug);
|
|
const target = state.roadmap?.phases.flatMap((phase) => phase.items).find((item) => item.title === title);
|
|
if (!target) throw new Error(`Missing autonomy fixture item '${title}'.`);
|
|
target.priority = priority;
|
|
const workspace = await prisma.workspaceState.findUniqueOrThrow({ where: { projectId }, select: { notesJson: true } });
|
|
const notes = typeof workspace.notesJson === "object" && workspace.notesJson !== null && !Array.isArray(workspace.notesJson) ? workspace.notesJson : {};
|
|
await prisma.workspaceState.update({ where: { projectId }, data: { notesJson: { ...notes, autonomy: state } as Prisma.InputJsonValue } });
|
|
};
|
|
|
|
const setAutonomyRoadmapOrder = async (projectId: string, slug: string, titles: string[]) => {
|
|
const state = await getAutonomyState(slug);
|
|
const itemOrder = new Map(titles.map((title, index) => [title, index]));
|
|
const items = state.roadmap?.phases.flatMap((phase) => phase.items) ?? [];
|
|
if (items.length !== titles.length || titles.some((title) => !items.some((item) => item.title === title))) {
|
|
throw new Error("The requested roadmap order does not match the source fixture.");
|
|
}
|
|
for (const phase of state.roadmap?.phases ?? []) {
|
|
phase.items.sort((left, right) => itemOrder.get(left.title)! - itemOrder.get(right.title)!);
|
|
}
|
|
const workspace = await prisma.workspaceState.findUniqueOrThrow({ where: { projectId }, select: { notesJson: true } });
|
|
const notes = typeof workspace.notesJson === "object" && workspace.notesJson !== null && !Array.isArray(workspace.notesJson) ? workspace.notesJson : {};
|
|
await prisma.workspaceState.update({ where: { projectId }, data: { notesJson: { ...notes, autonomy: state } as Prisma.InputJsonValue } });
|
|
};
|
|
|
|
type DatabaseLockWaiter = { pid: number; query: string; blockingPids: number[]; hasProjectRowShareLock: boolean };
|
|
const readDatabaseLockWaiters = () => prisma.$queryRaw<DatabaseLockWaiter[]>`
|
|
SELECT activity.pid, activity.query, pg_blocking_pids(activity.pid) AS "blockingPids",
|
|
EXISTS (
|
|
SELECT 1 FROM pg_locks
|
|
WHERE pg_locks.pid = activity.pid
|
|
AND pg_locks.relation = '"Project"'::regclass
|
|
AND pg_locks.mode = 'RowShareLock'
|
|
AND pg_locks.granted
|
|
) AS "hasProjectRowShareLock"
|
|
FROM pg_stat_activity AS activity
|
|
WHERE activity.datname = current_database()
|
|
AND activity.pid <> pg_backend_pid()
|
|
AND activity.state = 'active'
|
|
AND activity.wait_event_type = 'Lock'
|
|
`;
|
|
|
|
const isProjectCoordinationLockQuery = (query: string) => {
|
|
const normalized = query.toLowerCase();
|
|
return normalized.includes("for update") || normalized.includes("for no key update");
|
|
};
|
|
|
|
const waitForDatabaseLockWaiter = async (predicate: (waiter: DatabaseLockWaiter) => boolean, timeoutMs = 2000) => {
|
|
const deadline = Date.now() + timeoutMs;
|
|
while (Date.now() < deadline) {
|
|
const waiter = (await readDatabaseLockWaiters()).find(predicate);
|
|
if (waiter) return waiter;
|
|
await new Promise((resolve) => setTimeout(resolve, 20));
|
|
}
|
|
return undefined;
|
|
};
|
|
|
|
const createAuditInsertBarrier = async (projectId: string, eventType: "work.completed" | "work.reclaimed") => {
|
|
const suffix = randomUUID().replaceAll("-", "");
|
|
const triggerName = `test_audit_${suffix}`;
|
|
const functionName = `${triggerName}_fn`;
|
|
const advisoryKey = [Number.parseInt(suffix.slice(0, 7), 16), Number.parseInt(suffix.slice(7, 14), 16)] as const;
|
|
let blockerPid = 0;
|
|
let releaseAdvisoryLock: () => void = () => undefined;
|
|
let acquiredAdvisoryLock!: () => void;
|
|
let functionCreated = false;
|
|
let triggerCreated = false;
|
|
let lockHolder: Promise<void> | undefined;
|
|
const locked = new Promise<void>((resolve) => { acquiredAdvisoryLock = resolve; });
|
|
const hold = new Promise<void>((resolve) => { releaseAdvisoryLock = resolve; });
|
|
const cleanup = async () => {
|
|
releaseAdvisoryLock();
|
|
if (lockHolder) await lockHolder.catch(() => undefined);
|
|
if (triggerCreated) await prisma.$executeRawUnsafe(`DROP TRIGGER IF EXISTS ${triggerName} ON "WorkGraphAuditEvent"`);
|
|
if (functionCreated) await prisma.$executeRawUnsafe(`DROP FUNCTION IF EXISTS ${functionName}()`);
|
|
};
|
|
try {
|
|
await prisma.$executeRawUnsafe(`
|
|
CREATE FUNCTION ${functionName}() RETURNS trigger LANGUAGE plpgsql AS $$
|
|
BEGIN
|
|
PERFORM pg_advisory_xact_lock(${advisoryKey[0]}, ${advisoryKey[1]});
|
|
RETURN NEW;
|
|
END;
|
|
$$
|
|
`);
|
|
functionCreated = true;
|
|
await prisma.$executeRawUnsafe(`
|
|
CREATE TRIGGER ${triggerName}
|
|
BEFORE INSERT ON "WorkGraphAuditEvent"
|
|
FOR EACH ROW WHEN (NEW."projectId" = '${projectId}' AND NEW."eventType" = '${eventType}')
|
|
EXECUTE FUNCTION ${functionName}();
|
|
`);
|
|
triggerCreated = true;
|
|
lockHolder = prisma.$transaction(async (transaction) => {
|
|
const [backend] = await transaction.$queryRaw<Array<{ pid: number }>>`SELECT pg_backend_pid() AS pid`;
|
|
blockerPid = backend!.pid;
|
|
await transaction.$queryRaw`SELECT pg_advisory_xact_lock(${advisoryKey[0]}::integer, ${advisoryKey[1]}::integer) IS NULL`;
|
|
acquiredAdvisoryLock();
|
|
await hold;
|
|
});
|
|
await Promise.race([locked, lockHolder.then(() => { throw new Error("The advisory lock holder ended before acquiring its lock."); })]);
|
|
return { blockerPid, release: releaseAdvisoryLock, cleanup };
|
|
} catch (error) {
|
|
await cleanup();
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
const createWorkGraphNodeUpdateBarrier = async (nodeId: string) => {
|
|
const suffix = randomUUID().replaceAll("-", "");
|
|
const triggerName = `test_node_${suffix}`;
|
|
const functionName = `${triggerName}_fn`;
|
|
const advisoryKey = [Number.parseInt(suffix.slice(0, 7), 16), Number.parseInt(suffix.slice(7, 14), 16)] as const;
|
|
let blockerPid = 0;
|
|
let releaseAdvisoryLock: () => void = () => undefined;
|
|
let acquiredAdvisoryLock!: () => void;
|
|
let functionCreated = false;
|
|
let triggerCreated = false;
|
|
let lockHolder: Promise<void> | undefined;
|
|
const locked = new Promise<void>((resolve) => { acquiredAdvisoryLock = resolve; });
|
|
const hold = new Promise<void>((resolve) => { releaseAdvisoryLock = resolve; });
|
|
const cleanup = async () => {
|
|
releaseAdvisoryLock();
|
|
if (lockHolder) await lockHolder.catch(() => undefined);
|
|
if (triggerCreated) await prisma.$executeRawUnsafe(`DROP TRIGGER IF EXISTS ${triggerName} ON "WorkGraphNode"`);
|
|
if (functionCreated) await prisma.$executeRawUnsafe(`DROP FUNCTION IF EXISTS ${functionName}()`);
|
|
};
|
|
try {
|
|
await prisma.$executeRawUnsafe(`
|
|
CREATE FUNCTION ${functionName}() RETURNS trigger LANGUAGE plpgsql AS $$
|
|
BEGIN
|
|
PERFORM pg_advisory_xact_lock(${advisoryKey[0]}, ${advisoryKey[1]});
|
|
RETURN NEW;
|
|
END;
|
|
$$
|
|
`);
|
|
functionCreated = true;
|
|
await prisma.$executeRawUnsafe(`
|
|
CREATE TRIGGER ${triggerName}
|
|
BEFORE UPDATE ON "WorkGraphNode"
|
|
FOR EACH ROW WHEN (NEW."id" = '${nodeId}')
|
|
EXECUTE FUNCTION ${functionName}();
|
|
`);
|
|
triggerCreated = true;
|
|
lockHolder = prisma.$transaction(async (transaction) => {
|
|
const [backend] = await transaction.$queryRaw<Array<{ pid: number }>>`SELECT pg_backend_pid() AS pid`;
|
|
blockerPid = backend!.pid;
|
|
await transaction.$queryRaw`SELECT pg_advisory_xact_lock(${advisoryKey[0]}::integer, ${advisoryKey[1]}::integer) IS NULL`;
|
|
acquiredAdvisoryLock();
|
|
await hold;
|
|
});
|
|
await Promise.race([locked, lockHolder.then(() => { throw new Error("The advisory lock holder ended before acquiring its lock."); })]);
|
|
return { blockerPid, release: releaseAdvisoryLock, cleanup };
|
|
} catch (error) {
|
|
await cleanup();
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
databaseDescribe("autonomy database write isolation", () => {
|
|
it("preserves progress and the active lease when the same roadmap is imported again", async () => {
|
|
const slug = `autonomy-import-${Date.now()}`;
|
|
slugs.push(slug);
|
|
await createProject({ id: slug, name: "Roadmap import proof", description: "Isolated database regression" });
|
|
await configureAutonomy(slug, { enabled: true, autoBrainstorm: false }, "database-test");
|
|
const markdown = "## Build\n- Implement feature";
|
|
await importAutonomyRoadmap(slug, { markdown }, "database-test");
|
|
const claim = await claimAutonomyWork(slug, "database-test");
|
|
const repeated = await importAutonomyRoadmap(slug, { markdown: `\n${markdown}\n` }, "database-test");
|
|
expect(repeated.roadmap).toEqual(claim.state.roadmap);
|
|
expect(repeated.activeLease).toEqual(claim.state.activeLease);
|
|
await expect(importAutonomyRoadmap(slug, { markdown: "## Replacement\n- New task" }, "database-test")).rejects.toThrow("AUTO_MODE_WORK_ACTIVE");
|
|
expect((await getAutonomyState(slug)).activeLease?.token).toBe(claim.work!.token);
|
|
});
|
|
afterEach(() => vi.restoreAllMocks());
|
|
afterAll(async () => {
|
|
if (slugs.length) {
|
|
await prisma.deliveryPlan.deleteMany({ where: { project: { slug: { in: slugs } } } });
|
|
await prisma.project.deleteMany({ where: { slug: { in: slugs } } });
|
|
}
|
|
await prisma.$disconnect();
|
|
});
|
|
|
|
it("upgrades legacy autonomy state and preserves unrelated workspace notes", async () => {
|
|
const slug = `autonomy-legacy-${Date.now()}`;
|
|
slugs.push(slug);
|
|
await createProject({ id: slug, name: "Autonomy legacy proof", description: "Isolated database regression" });
|
|
const project = await prisma.project.findUniqueOrThrow({ where: { slug } });
|
|
await prisma.workspaceState.update({ where: { projectId: project.id }, data: { notesJson: { autonomy: {}, unrelated: { value: "preserve me" } } } });
|
|
const state = await configureAutonomy(slug, { enabled: true }, "database-test");
|
|
expect(state.enabled).toBe(true);
|
|
const workspace = await prisma.workspaceState.findUniqueOrThrow({ where: { projectId: project.id } });
|
|
expect(workspace.notesJson).toMatchObject({ unrelated: { value: "preserve me" }, autonomy: { enabled: true } });
|
|
});
|
|
|
|
it("advances the CAS version even when the clock does not advance", async () => {
|
|
const slug = `autonomy-clock-${Date.now()}`;
|
|
slugs.push(slug);
|
|
await createProject({ id: slug, name: "Autonomy clock proof", description: "Isolated database regression" });
|
|
const first = await configureAutonomy(slug, { enabled: true }, "database-test");
|
|
vi.spyOn(Date, "now").mockReturnValue(Date.parse(first.updatedAt));
|
|
const second = await configureAutonomy(slug, { enabled: false }, "database-test");
|
|
expect(Date.parse(second.updatedAt)).toBeGreaterThan(Date.parse(first.updatedAt));
|
|
expect(second.enabled).toBe(false);
|
|
});
|
|
|
|
it("resumes a failed implementation and executes its existing repair prerequisite first", async () => {
|
|
const slug = `autonomy-repair-${Date.now()}`;
|
|
slugs.push(slug);
|
|
await createProject({ id: slug, name: "Autonomy repair proof", description: "Isolated database regression" });
|
|
await configureAutonomy(slug, { enabled: true, autoBrainstorm: false }, "database-test");
|
|
await importAutonomyRoadmap(slug, { markdown: "## CI\n- Add gate\n- Fix source lint" }, "database-test");
|
|
const first = await claimAutonomyWork(slug, "database-test", "repair-run");
|
|
const report = await reportAutonomyWork(slug, { token: first.work!.token, outcome: "blocked", summary: "CI failed; no approval is required.", discoveredTasks: ["Fix source lint"] }, "database-test");
|
|
expect(report.state.status).toBe("running");
|
|
expect(report.addedTasks).toEqual([]);
|
|
const repair = await claimAutonomyWork(slug, "database-test", "repair-run");
|
|
expect(repair.work!.itemTitle).toBe("Fix source lint");
|
|
await expect(reportAutonomyWork(slug, { token: repair.work!.token, outcome: "success", summary: "Unproven success" }, "database-test")).rejects.toThrow("AUTO_MODE_DELIVERY_REQUIRED");
|
|
expect((await getAutonomyState(slug)).activeLease?.token).toBe(repair.work!.token);
|
|
});
|
|
|
|
it("retains one delivery across retries, repairs an open PR and invalidates stale evidence", async () => {
|
|
const slug = `autonomy-delivery-${Date.now()}`;
|
|
slugs.push(slug);
|
|
await createProject({ id: slug, name: "Delivery repair proof", description: "Isolated database regression" });
|
|
const project = await prisma.project.findUniqueOrThrow({ where: { slug } });
|
|
await prisma.giteaRepositoryLink.create({ data: { projectId: project.id, owner: "AutonomyProof", repository: slug, defaultBranch: "main", linkedBy: "database-test" } });
|
|
await configureAutonomy(slug, { enabled: true, autoBrainstorm: false }, "database-test");
|
|
await importAutonomyRoadmap(slug, { markdown: "## Build\n- Implement feature" }, "database-test");
|
|
const claim = await claimAutonomyWork(slug, "database-test", "delivery-run");
|
|
const plan = { title: "Implement feature", intent: "Complete feature", problem: "Broken flow", desiredOutcome: "Working flow", goals: ["repair"], acceptanceCriteria: ["tests pass"], implementationPlan: ["implement", "validate", "merge"], validationCommands: ["pnpm test"], riskLevel: "low" as const };
|
|
const delivery = await createOrResumeAutonomyDelivery(slug, plan, "database-test");
|
|
expect((await createOrResumeAutonomyDelivery(slug, { ...plan, title: "Unnecessary replacement" }, "database-test")).id).toBe(delivery.id);
|
|
await startFeatureDelivery(slug, delivery.id, "chatgpt/existing", "database-test");
|
|
await reportAutonomyWork(slug, { token: claim.work!.token, outcome: "failed", summary: "CI failed on existing branch" }, "database-test");
|
|
const resumed = await claimAutonomyWork(slug, "database-test", "delivery-run");
|
|
expect(resumed.work!.deliveryId).toBe(delivery.id);
|
|
const evidence = { provider: "gitea_actions" as const, runId: 1, runNumber: 1, url: "https://gitea.example.com/runs/1", workflowPath: ".gitea/workflows/ci.yml", headSha: "a".repeat(40), conclusion: "success" as const, verifiedAt: new Date().toISOString() };
|
|
await recordFeatureDeliveryActionValidation(slug, delivery.id, evidence, "database-test");
|
|
await openFeatureDeliveryPullRequest(slug, delivery.id, { number: 1, url: "https://gitea.example.com/pulls/1", title: "Feature" }, "database-test");
|
|
await expect(reportAutonomyWork(slug, { token: resumed.work!.token, outcome: "success", summary: "PR opened" }, "database-test")).rejects.toThrow("AUTO_MODE_DELIVERY_NOT_MERGED");
|
|
expect((await getAutonomyState(slug)).activeLease?.token).toBe(resumed.work!.token);
|
|
const head = "b".repeat(40);
|
|
let remoteMerged = false;
|
|
vi.spyOn(GiteaClient.prototype, "getPullRequest").mockImplementation(async () => ({ number: 1, title: "Feature", html_url: "https://gitea.example.com/pulls/1", state: remoteMerged ? "closed" : "open", merged: remoteMerged, merge_commit_sha: remoteMerged ? "c".repeat(40) : undefined, head: { ref: "chatgpt/existing", sha: head }, base: { ref: "main", sha: "d".repeat(40) }, mergeable: true }));
|
|
vi.spyOn(GiteaClient.prototype, "getBranch").mockResolvedValue({ name: "chatgpt/existing", commit: { id: head, message: "Repair" }, protected: false });
|
|
vi.spyOn(GiteaClient.prototype, "getContents").mockResolvedValue({ type: "file", path: "src/feature.ts", name: "feature.ts", sha: "file-sha", size: 4, encoding: "base64", content: "dGVzdA==" });
|
|
const write = vi.spyOn(GiteaClient.prototype, "updateFile").mockResolvedValue({});
|
|
vi.spyOn(GiteaClient.prototype, "listActionRuns").mockResolvedValue({ total_count: 2, workflow_runs: [
|
|
{ id: 2, run_number: 2, display_title: "Managed validation / full", path: ".gitea/workflows/managed-validation.yml", event: "pull_request", head_sha: head, head_branch: "chatgpt/existing", status: "completed", conclusion: "success", html_url: "https://gitea.example.com/runs/2" },
|
|
{ id: 3, run_number: 3, display_title: "CI", path: ".gitea/workflows/ci.yml", event: "pull_request", head_sha: head, head_branch: "chatgpt/existing", status: "completed", conclusion: "success", html_url: "https://gitea.example.com/runs/3" },
|
|
] });
|
|
vi.spyOn(GiteaClient.prototype, "getBranchProtection").mockResolvedValue({ enable_status_check: true, status_check_contexts: ["CI / test"] });
|
|
vi.spyOn(GiteaClient.prototype, "getCombinedCommitStatus").mockResolvedValue({ state: "success", statuses: [{ context: "CI / test", status: "success" }] });
|
|
const merge = vi.spyOn(GiteaClient.prototype, "mergePullRequest").mockImplementation(async () => { remoteMerged = true; });
|
|
const server = createProjectBrainMcpServer(loadEnv({ NODE_ENV: "test", DATABASE_URL: databaseUrl, PROJECTBRAIN_DATA_SOURCE: "database", PROJECTBRAIN_OWNER_USERNAME: "owner", PROJECTBRAIN_OWNER_PASSWORD: "database-proof-password", PROJECTBRAIN_AUTH_SECRET: "test-secret-with-at-least-thirty-two-characters", PROJECTBRAIN_GITEA_URL: "https://gitea.example.com", PROJECTBRAIN_GITEA_TOKEN: "test-gitea-token-with-at-least-twenty-characters" }), "database-test");
|
|
const client = new Client({ name: "delivery-recovery-proof", version: "1" });
|
|
const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
|
|
await server.connect(serverTransport);
|
|
await client.connect(clientTransport);
|
|
const written = await client.callTool({ name: "write_feature_file", arguments: { project_id: slug, delivery_id: delivery.id, branch: "chatgpt/existing", path: "src/feature.ts", content: "fixed", message: "Repair failing validation", expected_sha: "file-sha" } });
|
|
expect(written.isError, JSON.stringify(written.content)).not.toBe(true);
|
|
expect(write).toHaveBeenCalledTimes(1);
|
|
const repaired = await getFeatureDelivery(slug, delivery.id);
|
|
expect(repaired.spec.status).toBe("pull_request_open");
|
|
expect(repaired.spec.pullRequest?.number).toBe(1);
|
|
expect(repaired.spec.validationEvidence).toBeUndefined();
|
|
expect(repaired.spec.validationResults).toEqual([]);
|
|
const synced = await client.callTool({ name: "sync_feature_validation", arguments: { project_id: slug, delivery_id: delivery.id } });
|
|
expect(synced.isError, JSON.stringify(synced.content)).not.toBe(true);
|
|
const merged = await client.callTool({ name: "merge_feature_delivery", arguments: { project_id: slug, delivery_id: delivery.id, expected_head_sha: head, delete_branch: false } });
|
|
expect(merged.isError, JSON.stringify(merged.content)).not.toBe(true);
|
|
expect(merge).toHaveBeenCalledTimes(1);
|
|
const dbPlan = await prisma.deliveryPlan.findFirstOrThrow({ where: { projectId: project.id, slug: delivery.id } });
|
|
// Simulate a previous response/webhook interruption after Gitea merged.
|
|
await prisma.deliveryPlan.update({ where: { id: dbPlan.id }, data: { status: "pull_request_open" } });
|
|
const replay = await client.callTool({ name: "merge_feature_delivery", arguments: { project_id: slug, delivery_id: delivery.id, expected_head_sha: head, delete_branch: false } });
|
|
expect(replay.isError, JSON.stringify(replay.content)).not.toBe(true);
|
|
expect(merge).toHaveBeenCalledTimes(1);
|
|
await client.close();
|
|
await server.close();
|
|
const completed = await reportAutonomyWork(slug, { token: resumed.work!.token, outcome: "success", summary: "Validated branch merged" }, "database-test");
|
|
expect(completed.state.roadmap!.phases[0].items[0].status).toBe("completed");
|
|
});
|
|
|
|
it("retires a removed branch only after proving its recorded work is included in main", async () => {
|
|
const slug = `autonomy-integrated-${Date.now()}`;
|
|
slugs.push(slug);
|
|
await createProject({ id: slug, name: "Integration proof", description: "Isolated database regression" });
|
|
const project = await prisma.project.findUniqueOrThrow({ where: { slug } });
|
|
await prisma.giteaRepositoryLink.create({ data: { projectId: project.id, owner: "AutonomyProof", repository: slug, defaultBranch: "main", linkedBy: "database-test" } });
|
|
const delivery = await createFeatureDelivery(slug, { title: "Integrated work", intent: "Repair", problem: "Bug", desiredOutcome: "Fixed", goals: ["fix"], acceptanceCriteria: ["verified"], implementationPlan: ["fix"], validationCommands: ["test"], riskLevel: "low" }, "database-test");
|
|
await startFeatureDelivery(slug, delivery.id, "chatgpt/integrated", "database-test");
|
|
await recordFeatureDeliveryProgress(slug, delivery.id, { headSha: "a".repeat(40) }, "database-test");
|
|
vi.spyOn(GiteaClient.prototype, "getBranch").mockImplementation(async (_owner, _repository, branch) => {
|
|
if (branch !== "main") throw new GiteaApiError(404, "GITEA_HTTP_404", "Branch removed");
|
|
return { name: "main", commit: { id: "b".repeat(40) } };
|
|
});
|
|
const compare = vi.spyOn(GiteaClient.prototype, "compareCommits").mockResolvedValueOnce({ total_commits: 1 }).mockResolvedValueOnce({ total_commits: 0 });
|
|
const client = new GiteaClient("https://gitea.example.com", "test-token");
|
|
expect((await refreshDeliveryFromGitea(client, slug, delivery.id)).spec.status).toBe("executing");
|
|
const integrated = await refreshDeliveryFromGitea(client, slug, delivery.id);
|
|
expect(integrated.spec.status).toBe("superseded");
|
|
expect(integrated.spec.validationEvidence).toBeUndefined();
|
|
expect(compare).toHaveBeenLastCalledWith("AutonomyProof", slug, "b".repeat(40), "a".repeat(40));
|
|
});
|
|
|
|
it("serializes concurrent dependency edits before checking for cycles", async () => {
|
|
const { slug, project, graph } = await createWorkGraphProject("## Work\n- Task A\n- Task B");
|
|
const taskA = nodeByTitle(graph, "Task A");
|
|
const taskB = nodeByTitle(graph, "Task B");
|
|
const suffix = randomUUID().replaceAll("-", "");
|
|
const triggerName = `test_cycle_${suffix}`;
|
|
const functionName = `${triggerName}_fn`;
|
|
const advisoryKey = [Number.parseInt(suffix.slice(0, 7), 16), Number.parseInt(suffix.slice(7, 14), 16)] as const;
|
|
let blockerPid = 0;
|
|
let releaseAdvisoryLock: () => void = () => undefined;
|
|
let acquiredAdvisoryLock!: () => void;
|
|
let functionCreated = false;
|
|
let triggerCreated = false;
|
|
const locked = new Promise<void>((resolve) => { acquiredAdvisoryLock = resolve; });
|
|
const hold = new Promise<void>((resolve) => { releaseAdvisoryLock = resolve; });
|
|
let lockHolder: Promise<void> | undefined;
|
|
let edits: Array<Promise<Awaited<ReturnType<typeof updateWorkDependencies>>>> | undefined;
|
|
try {
|
|
await prisma.$executeRawUnsafe(`
|
|
CREATE FUNCTION ${functionName}() RETURNS trigger LANGUAGE plpgsql AS $$
|
|
BEGIN
|
|
PERFORM pg_advisory_xact_lock(${advisoryKey[0]}, ${advisoryKey[1]});
|
|
RETURN NEW;
|
|
END;
|
|
$$
|
|
`);
|
|
functionCreated = true;
|
|
await prisma.$executeRawUnsafe(`
|
|
CREATE TRIGGER ${triggerName}
|
|
BEFORE INSERT ON "WorkGraphDependency"
|
|
FOR EACH ROW WHEN (NEW."projectId" = '${project.id}')
|
|
EXECUTE FUNCTION ${functionName}();
|
|
`);
|
|
triggerCreated = true;
|
|
lockHolder = prisma.$transaction(async (transaction) => {
|
|
const [backend] = await transaction.$queryRaw<Array<{ pid: number }>>`SELECT pg_backend_pid() AS pid`;
|
|
blockerPid = backend!.pid;
|
|
await transaction.$queryRaw`SELECT pg_advisory_xact_lock(${advisoryKey[0]}::integer, ${advisoryKey[1]}::integer) IS NULL`;
|
|
acquiredAdvisoryLock();
|
|
await hold;
|
|
});
|
|
await Promise.race([locked, lockHolder.then(() => { throw new Error("The advisory lock holder ended before acquiring its lock."); })]);
|
|
edits = [
|
|
updateWorkDependencies(slug, taskA.id, [taskB.id], "database-test"),
|
|
updateWorkDependencies(slug, taskB.id, [taskA.id], "database-test"),
|
|
];
|
|
const waitDeadline = Date.now() + 2000;
|
|
let bothAtSerializedBoundary = false;
|
|
while (!bothAtSerializedBoundary && Date.now() < waitDeadline) {
|
|
const waiters = await readDatabaseLockWaiters();
|
|
const blockedInserts = waiters.filter((row) => row.query.toLowerCase().includes("workgraphdependency") && row.blockingPids.includes(blockerPid));
|
|
const projectLockWaiters = waiters.filter((row) => isProjectCoordinationLockQuery(row.query));
|
|
const baselinePair = blockedInserts.length >= 2;
|
|
const serializedPair = blockedInserts.length === 1 && projectLockWaiters.some((row) => row.blockingPids.includes(blockedInserts[0]!.pid));
|
|
bothAtSerializedBoundary = baselinePair || serializedPair;
|
|
if (!bothAtSerializedBoundary) await new Promise((resolve) => setTimeout(resolve, 20));
|
|
}
|
|
expect(bothAtSerializedBoundary).toBe(true);
|
|
releaseAdvisoryLock();
|
|
const results = await Promise.allSettled(edits);
|
|
expect(results.filter((result) => result.status === "fulfilled")).toHaveLength(1);
|
|
const rejected = results.filter((result): result is PromiseRejectedResult => result.status === "rejected");
|
|
expect(rejected).toHaveLength(1);
|
|
expect(rejected[0]?.reason).toMatchObject({ message: "WORK_GRAPH_DEPENDENCY_CYCLE" });
|
|
const finalGraph = await getProjectWorkGraph(slug);
|
|
const finalA = nodeByTitle(finalGraph, "Task A");
|
|
const finalB = nodeByTitle(finalGraph, "Task B");
|
|
expect(finalA.dependencies.some((edge) => edge.dependsOnNodeId === finalB.id)).not.toBe(finalB.dependencies.some((edge) => edge.dependsOnNodeId === finalA.id));
|
|
} finally {
|
|
releaseAdvisoryLock();
|
|
if (lockHolder) await lockHolder.catch(() => undefined);
|
|
if (edits) await Promise.allSettled(edits);
|
|
if (triggerCreated) await prisma.$executeRawUnsafe(`DROP TRIGGER IF EXISTS ${triggerName} ON "WorkGraphDependency"`);
|
|
if (functionCreated) await prisma.$executeRawUnsafe(`DROP FUNCTION IF EXISTS ${functionName}()`);
|
|
}
|
|
}, 15_000);
|
|
|
|
it("does not attach a new unresolved prerequisite to work with an active lease", async () => {
|
|
const { slug, project } = await createWorkGraphProject("## Work\n- Runnable task\n- Prerequisite task");
|
|
await setAutonomyPriority(project.id, slug, "Runnable task", 100);
|
|
const currentGraph = await getProjectWorkGraph(slug);
|
|
const task = nodeByTitle(currentGraph, "Runnable task");
|
|
const prerequisite = nodeByTitle(currentGraph, "Prerequisite task");
|
|
const beforeDependencies = await prisma.workGraphDependency.findMany({ where: { projectId: project.id, nodeId: task.id }, select: { dependsOnNodeId: true, dependencyType: true, createdBy: true } });
|
|
expect(beforeDependencies).toHaveLength(0);
|
|
const claim = await claimReadyWork(slug, "claimant");
|
|
expect(claim?.node.id).toBe(task.id);
|
|
expect(claim?.node.dependencies.map((edge) => edge.dependsOnNodeId)).toEqual(beforeDependencies.map((edge) => edge.dependsOnNodeId));
|
|
await expect(updateWorkDependencies(slug, task.id, [prerequisite.id], "database-test")).rejects.toThrow("WORK_GRAPH_ACTIVE_LEASE");
|
|
const persisted = await prisma.workGraphDependency.findMany({ where: { projectId: project.id, nodeId: task.id }, select: { dependsOnNodeId: true, dependencyType: true, createdBy: true } });
|
|
expect(persisted).toEqual(beforeDependencies);
|
|
});
|
|
|
|
it("serializes a dependency edit behind an in-flight claim", async () => {
|
|
const { slug, project } = await createWorkGraphProject("## Work\n- Runnable task\n- Prerequisite task");
|
|
await setAutonomyPriority(project.id, slug, "Runnable task", 100);
|
|
const currentGraph = await getProjectWorkGraph(slug);
|
|
const task = nodeByTitle(currentGraph, "Runnable task");
|
|
const prerequisite = nodeByTitle(currentGraph, "Prerequisite task");
|
|
const suffix = randomUUID().replaceAll("-", "");
|
|
const triggerName = `test_claim_${suffix}`;
|
|
const functionName = `${triggerName}_fn`;
|
|
const advisoryKey = [Number.parseInt(suffix.slice(0, 7), 16), Number.parseInt(suffix.slice(7, 14), 16)] as const;
|
|
|
|
let releaseAdvisoryLock: () => void = () => undefined;
|
|
let acquiredAdvisoryLock!: () => void;
|
|
let blockerPid = 0;
|
|
let functionCreated = false;
|
|
let triggerCreated = false;
|
|
const beforeDependencies = await prisma.workGraphDependency.findMany({ where: { projectId: project.id, nodeId: task.id }, select: { dependsOnNodeId: true, dependencyType: true, createdBy: true } });
|
|
expect(beforeDependencies).toHaveLength(0);
|
|
const locked = new Promise<void>((resolve) => { acquiredAdvisoryLock = resolve; });
|
|
const hold = new Promise<void>((resolve) => { releaseAdvisoryLock = resolve; });
|
|
let claim: ReturnType<typeof claimReadyWork> | undefined;
|
|
let edit: Promise<{ status: "fulfilled" } | { status: "rejected"; error: unknown }> | undefined;
|
|
let editSettled = false;
|
|
let lockHolder: Promise<void> | undefined;
|
|
try {
|
|
await prisma.$executeRawUnsafe(`
|
|
CREATE FUNCTION ${functionName}() RETURNS trigger LANGUAGE plpgsql AS $$
|
|
BEGIN
|
|
PERFORM pg_advisory_xact_lock(${advisoryKey[0]}, ${advisoryKey[1]});
|
|
RETURN NEW;
|
|
END;
|
|
$$
|
|
`);
|
|
functionCreated = true;
|
|
await prisma.$executeRawUnsafe(`
|
|
CREATE TRIGGER ${triggerName}
|
|
BEFORE UPDATE ON "WorkGraphNode"
|
|
FOR EACH ROW WHEN (NEW."projectId" = '${project.id}' AND NEW."owner" IS NOT NULL AND OLD."owner" IS DISTINCT FROM NEW."owner")
|
|
EXECUTE FUNCTION ${functionName}();
|
|
`);
|
|
triggerCreated = true;
|
|
lockHolder = prisma.$transaction(async (transaction) => {
|
|
const [backend] = await transaction.$queryRaw<Array<{ pid: number }>>`SELECT pg_backend_pid() AS pid`;
|
|
blockerPid = backend!.pid;
|
|
await transaction.$queryRaw`SELECT pg_advisory_xact_lock(${advisoryKey[0]}::integer, ${advisoryKey[1]}::integer) IS NULL`;
|
|
acquiredAdvisoryLock();
|
|
await hold;
|
|
});
|
|
await Promise.race([locked, lockHolder!.then(() => { throw new Error("The advisory lock holder ended before acquiring its lock."); })]);
|
|
claim = claimReadyWork(slug, "claimant");
|
|
const waitDeadline = Date.now() + 2000;
|
|
let claimWaiter: DatabaseLockWaiter | undefined;
|
|
while (!claimWaiter && Date.now() < waitDeadline) {
|
|
claimWaiter = (await readDatabaseLockWaiters()).find((row) => row.query.toLowerCase().includes("update") && row.query.toLowerCase().includes("workgraphnode") && row.blockingPids.includes(blockerPid));
|
|
if (!claimWaiter) await new Promise((resolve) => setTimeout(resolve, 20));
|
|
}
|
|
expect(claimWaiter).toBeDefined();
|
|
|
|
edit = updateWorkDependencies(slug, task.id, [prerequisite.id], "database-test").then(
|
|
() => ({ status: "fulfilled" as const }),
|
|
(error: unknown) => ({ status: "rejected" as const, error }),
|
|
).finally(() => { editSettled = true; });
|
|
const editWaitDeadline = Date.now() + 2000;
|
|
let dependencyEditWaiter: DatabaseLockWaiter | undefined;
|
|
while (!dependencyEditWaiter && !editSettled && Date.now() < editWaitDeadline) {
|
|
dependencyEditWaiter = (await readDatabaseLockWaiters()).find((row) => isProjectCoordinationLockQuery(row.query) && row.blockingPids.includes(claimWaiter!.pid));
|
|
if (!dependencyEditWaiter && !editSettled) await new Promise((resolve) => setTimeout(resolve, 20));
|
|
}
|
|
expect(editSettled).toBe(false);
|
|
expect(dependencyEditWaiter).toBeDefined();
|
|
} finally {
|
|
releaseAdvisoryLock?.();
|
|
if (lockHolder) await lockHolder.catch(() => undefined);
|
|
if (claim) await claim.catch(() => undefined);
|
|
if (edit) await edit.catch(() => undefined);
|
|
if (triggerCreated) await prisma.$executeRawUnsafe(`DROP TRIGGER IF EXISTS ${triggerName} ON "WorkGraphNode"`);
|
|
if (functionCreated) await prisma.$executeRawUnsafe(`DROP FUNCTION IF EXISTS ${functionName}()`);
|
|
}
|
|
|
|
const claimResult = await claim!;
|
|
expect(claimResult?.node.id).toBe(task.id);
|
|
expect(claimResult?.node.dependencies.map((edge) => edge.dependsOnNodeId)).toEqual(beforeDependencies.map((edge) => edge.dependsOnNodeId));
|
|
const editResult = await edit!;
|
|
expect(editResult.status).toBe("rejected");
|
|
if (editResult.status === "rejected") expect(editResult.error).toMatchObject({ message: "WORK_GRAPH_ACTIVE_LEASE" });
|
|
const persisted = await prisma.workGraphDependency.findMany({ where: { projectId: project.id, nodeId: task.id }, select: { dependsOnNodeId: true, dependencyType: true, createdBy: true } });
|
|
expect(persisted).toEqual(beforeDependencies);
|
|
}, 15_000);
|
|
|
|
it("keeps completion audit foreign-key checks compatible with a waiting graph sync", async () => {
|
|
const { slug, project, graph } = await createWorkGraphProject("## Work\n- Completing task\n- Other task");
|
|
await setAutonomyPriority(project.id, slug, "Completing task", 100);
|
|
const task = nodeByTitle(graph, "Completing task");
|
|
const claim = await claimReadyWork(slug, "completion-worker");
|
|
expect(claim?.node.id).toBe(task.id);
|
|
const barrier = await createAuditInsertBarrier(project.id, "work.completed");
|
|
let completion: ReturnType<typeof recordWorkCompletion> | undefined;
|
|
let sync: ReturnType<typeof syncProjectWorkGraph> | undefined;
|
|
try {
|
|
completion = recordWorkCompletion(slug, task.id, "completion-worker", claim!.leaseToken, { summary: "Completion lock-order proof" });
|
|
const completionWaiter = await waitForDatabaseLockWaiter((waiter) => waiter.query.toLowerCase().includes("workgraphauditevent") && waiter.blockingPids.includes(barrier.blockerPid));
|
|
expect(completionWaiter).toBeDefined();
|
|
|
|
sync = syncProjectWorkGraph(slug);
|
|
const syncWaiter = await waitForDatabaseLockWaiter((waiter) => waiter.query.toLowerCase().includes("workgraphnode") && waiter.blockingPids.includes(completionWaiter!.pid) && waiter.hasProjectRowShareLock);
|
|
expect(syncWaiter).toBeDefined();
|
|
|
|
barrier.release();
|
|
const results = await Promise.allSettled([completion, sync]);
|
|
expect(results.map((result) => result.status)).toEqual(["fulfilled", "fulfilled"]);
|
|
} finally {
|
|
barrier.release();
|
|
await Promise.allSettled([...(completion ? [completion] : []), ...(sync ? [sync] : [])]);
|
|
await barrier.cleanup();
|
|
}
|
|
}, 15_000);
|
|
|
|
it("keeps expired-work audit foreign-key checks compatible with a waiting claim", async () => {
|
|
const { slug, project, graph } = await createWorkGraphProject("## Work\n- Expired task\n- Other task");
|
|
await setAutonomyPriority(project.id, slug, "Expired task", 100);
|
|
const task = nodeByTitle(graph, "Expired task");
|
|
const initialClaim = await claimReadyWork(slug, "expired-worker");
|
|
expect(initialClaim?.node.id).toBe(task.id);
|
|
await prisma.workGraphNode.update({ where: { id: task.id }, data: { leaseExpiresAt: new Date(Date.now() - 60_000) } });
|
|
const barrier = await createAuditInsertBarrier(project.id, "work.reclaimed");
|
|
let reclaim: ReturnType<typeof reclaimExpiredWork> | undefined;
|
|
let claimAfterExpiry: ReturnType<typeof claimReadyWork> | undefined;
|
|
try {
|
|
reclaim = reclaimExpiredWork(slug);
|
|
const reclaimWaiter = await waitForDatabaseLockWaiter((waiter) => waiter.query.toLowerCase().includes("workgraphauditevent") && waiter.blockingPids.includes(barrier.blockerPid));
|
|
expect(reclaimWaiter).toBeDefined();
|
|
|
|
claimAfterExpiry = claimReadyWork(slug, "reclaim-race-claimant");
|
|
const claimWaiter = await waitForDatabaseLockWaiter((waiter) => isProjectCoordinationLockQuery(waiter.query) && waiter.blockingPids.includes(reclaimWaiter!.pid));
|
|
expect(claimWaiter).toBeDefined();
|
|
|
|
barrier.release();
|
|
const [reclaimResult, claimResult] = await Promise.all([reclaim, claimAfterExpiry]);
|
|
expect(reclaimResult.reclaimedCount).toBe(1);
|
|
expect(claimResult?.node.id).toBe(task.id);
|
|
} finally {
|
|
barrier.release();
|
|
await Promise.allSettled([...(reclaim ? [reclaim] : []), ...(claimAfterExpiry ? [claimAfterExpiry] : [])]);
|
|
await barrier.cleanup();
|
|
}
|
|
}, 15_000);
|
|
|
|
it("serializes multi-node reclaim before it can invert locks with graph reconciliation", async () => {
|
|
const { slug, project, graph } = await createWorkGraphProject("## Work\n- Task B\n- Task A");
|
|
const taskA = nodeByTitle(graph, "Task A");
|
|
const taskB = nodeByTitle(graph, "Task B");
|
|
const now = Date.now();
|
|
await prisma.workGraphNode.update({ where: { id: taskB.id }, data: { owner: "expired-worker", leaseToken: randomUUID(), leaseExpiresAt: new Date(now - 120_000), executionEligibility: "running", canonicalLifecycle: "running" } });
|
|
await prisma.workGraphNode.update({ where: { id: taskA.id }, data: { owner: "expired-worker", leaseToken: randomUUID(), leaseExpiresAt: new Date(now - 60_000), executionEligibility: "running", canonicalLifecycle: "running" } });
|
|
const reclaimWhere = { projectId: project.id, leaseExpiresAt: { lt: new Date() }, owner: { not: null }, executionEligibility: "running" as const };
|
|
const reclaimOrder = await prisma.workGraphNode.findMany({ where: reclaimWhere, select: { id: true, title: true } });
|
|
expect(reclaimOrder).toHaveLength(2);
|
|
const graphOrder = reclaimOrder.map((node) => node.title).reverse();
|
|
await setAutonomyRoadmapOrder(project.id, slug, graphOrder);
|
|
|
|
const graphFirstNode = graphOrder[0] === "Task A" ? taskA : taskB;
|
|
const barrier = await createWorkGraphNodeUpdateBarrier(graphFirstNode.id);
|
|
let sync: ReturnType<typeof syncProjectWorkGraph> | undefined;
|
|
let reclaim: ReturnType<typeof reclaimExpiredWork> | undefined;
|
|
try {
|
|
sync = syncProjectWorkGraph(slug);
|
|
const syncWaiter = await waitForDatabaseLockWaiter((waiter) => waiter.query.toLowerCase().includes("workgraphnode") && waiter.blockingPids.includes(barrier.blockerPid) && waiter.hasProjectRowShareLock);
|
|
expect(syncWaiter).toBeDefined();
|
|
|
|
reclaim = reclaimExpiredWork(slug);
|
|
const reclaimProjectWaiter = await waitForDatabaseLockWaiter((waiter) => isProjectCoordinationLockQuery(waiter.query) && waiter.blockingPids.includes(syncWaiter!.pid));
|
|
const reclaimNodeWaiter = reclaimProjectWaiter ? undefined : await waitForDatabaseLockWaiter((waiter) => waiter.query.toLowerCase().includes("workgraphnode") && waiter.blockingPids.includes(syncWaiter!.pid));
|
|
expect(reclaimProjectWaiter ?? reclaimNodeWaiter).toBeDefined();
|
|
|
|
barrier.release();
|
|
if (reclaimNodeWaiter) {
|
|
const graphReverseWaiter = await waitForDatabaseLockWaiter((waiter) => waiter.query.toLowerCase().includes("workgraphnode") && waiter.blockingPids.includes(reclaimNodeWaiter.pid) && waiter.hasProjectRowShareLock);
|
|
expect(graphReverseWaiter).toBeDefined();
|
|
}
|
|
const results = await Promise.allSettled([sync, reclaim]);
|
|
const failures = results.filter((result): result is PromiseRejectedResult => result.status === "rejected");
|
|
expect(results.map((result) => result.status), failures.map((failure) => String(failure.reason)).join("\n")).toEqual(["fulfilled", "fulfilled"]);
|
|
} finally {
|
|
barrier.release();
|
|
await Promise.allSettled([...(sync ? [sync] : []), ...(reclaim ? [reclaim] : [])]);
|
|
await barrier.cleanup();
|
|
}
|
|
}, 15_000);
|
|
|
|
it("keeps a live lease's derived dependencies until expiry, then applies the latest source edges", async () => {
|
|
const { slug, project } = await createWorkGraphProject("## Work\n- Runnable task\n- Prerequisite task");
|
|
await setAutonomyPriority(project.id, slug, "Runnable task", 100);
|
|
const graph = await getProjectWorkGraph(slug);
|
|
const task = nodeByTitle(graph, "Runnable task");
|
|
const prerequisite = nodeByTitle(graph, "Prerequisite task");
|
|
const claim = await claimReadyWork(slug, "claimant");
|
|
expect(claim?.node.id).toBe(task.id);
|
|
expect(claim?.node.dependencies).toHaveLength(0);
|
|
|
|
await setAutonomyDependencies(project.id, slug, "Runnable task", ["Prerequisite task"]);
|
|
const duringLease = await getProjectWorkGraph(slug);
|
|
const leasedTask = nodeByTitle(duringLease, "Runnable task");
|
|
expect(leasedTask.executionEligibility).toBe("running");
|
|
expect(leasedTask.dependencies).toHaveLength(0);
|
|
|
|
await prisma.workGraphNode.update({ where: { id: task.id }, data: { leaseExpiresAt: new Date(Date.now() - 60_000) } });
|
|
const afterExpiry = await getProjectWorkGraph(slug);
|
|
const blockedTask = nodeByTitle(afterExpiry, "Runnable task");
|
|
expect(blockedTask.executionEligibility).toBe("waiting");
|
|
expect(blockedTask.dependencies.map((edge) => edge.dependsOnNodeId)).toEqual([prerequisite.id]);
|
|
const nextClaim = await claimReadyWork(slug, "next-claimant");
|
|
expect(nextClaim?.node.id).toBe(prerequisite.id);
|
|
expect(nextClaim?.node.id).not.toBe(task.id);
|
|
}, 15_000);
|
|
|
|
it("keeps the old complete derived edge set visible until reconciliation commits", async () => {
|
|
const { slug, project } = await createWorkGraphProject("## Work\n- Task A\n- Task B\n- Task C");
|
|
await setAutonomyDependencies(project.id, slug, "Task A", ["Task B"]);
|
|
const initialGraph = await getProjectWorkGraph(slug);
|
|
const taskA = nodeByTitle(initialGraph, "Task A");
|
|
const taskB = nodeByTitle(initialGraph, "Task B");
|
|
const taskC = nodeByTitle(initialGraph, "Task C");
|
|
await setAutonomyDependencies(project.id, slug, "Task A", ["Task C"]);
|
|
|
|
let releaseProjectLock!: () => void;
|
|
let acquiredProjectLock!: () => void;
|
|
let blockerPid = 0;
|
|
const projectLocked = new Promise<void>((resolve) => { acquiredProjectLock = resolve; });
|
|
const hold = new Promise<void>((resolve) => { releaseProjectLock = resolve; });
|
|
const lockHolder = prisma.$transaction(async (transaction) => {
|
|
const [backend] = await transaction.$queryRaw<Array<{ pid: number }>>`SELECT pg_backend_pid() AS pid`;
|
|
blockerPid = backend!.pid;
|
|
await transaction.$queryRaw`SELECT "id" FROM "Project" WHERE "id" = ${project.id} FOR UPDATE`;
|
|
acquiredProjectLock();
|
|
await hold;
|
|
});
|
|
let sync: Promise<string> | undefined;
|
|
try {
|
|
await Promise.race([projectLocked, lockHolder.then(() => { throw new Error("The project lock holder ended before acquiring its lock."); })]);
|
|
let syncFinished = false;
|
|
sync = syncProjectWorkGraph(slug).then((result) => { syncFinished = true; return result; });
|
|
const waitDeadline = Date.now() + 5000;
|
|
let waitingTransactions: DatabaseLockWaiter[] = [];
|
|
while (!waitingTransactions.length && Date.now() < waitDeadline) {
|
|
waitingTransactions = (await readDatabaseLockWaiters()).filter((row) => row.blockingPids.includes(blockerPid));
|
|
if (!waitingTransactions.length) await new Promise((resolve) => setTimeout(resolve, 20));
|
|
}
|
|
expect(waitingTransactions.length).toBeGreaterThan(0);
|
|
expect(syncFinished).toBe(false);
|
|
const duringSync = await prisma.workGraphDependency.findMany({ where: { projectId: project.id, createdBy: "autonomy-sync" } });
|
|
expect(duringSync.map((edge) => [edge.nodeId, edge.dependsOnNodeId])).toEqual([[taskA.id, taskB.id]]);
|
|
} finally {
|
|
releaseProjectLock();
|
|
await lockHolder.catch(() => undefined);
|
|
if (sync) await sync;
|
|
}
|
|
|
|
const afterSync = await prisma.workGraphDependency.findMany({ where: { projectId: project.id, createdBy: "autonomy-sync" } });
|
|
expect(afterSync.map((edge) => [edge.nodeId, edge.dependsOnNodeId])).toEqual([[taskA.id, taskC.id]]);
|
|
}, 15_000);
|
|
|
|
it("rechecks prerequisites before treating an expired lease as reclaimable", async () => {
|
|
const { slug, project, graph } = await createWorkGraphProject("## Work\n- Dependent task\n- Prerequisite task");
|
|
const task = nodeByTitle(graph, "Dependent task");
|
|
const prerequisite = nodeByTitle(graph, "Prerequisite task");
|
|
await updateWorkDependencies(slug, task.id, [prerequisite.id], "database-test");
|
|
await prisma.workGraphNode.update({ where: { id: task.id }, data: {
|
|
owner: "expired-worker",
|
|
leaseToken: randomUUID(),
|
|
leaseExpiresAt: new Date(Date.now() - 60_000),
|
|
executionEligibility: "running",
|
|
canonicalLifecycle: "running",
|
|
} });
|
|
|
|
const snapshot = await getProjectWorkGraph(slug);
|
|
expect(nodeByTitle(snapshot, "Dependent task").executionEligibility).toBe("waiting");
|
|
expect(nodeByTitle(snapshot, "Dependent task").dependencies.some((edge) => edge.dependsOnNodeId === prerequisite.id)).toBe(true);
|
|
const claim = await claimReadyWork(slug, "claimant");
|
|
expect(claim?.node.id).toBe(prerequisite.id);
|
|
expect(claim?.node.id).not.toBe(task.id);
|
|
});
|
|
});
|