mirror of
https://github.com/paperclipai/paperclip.git
synced 2026-11-05 03:51:54 +01:00
246 lines
22 KiB
TypeScript
246 lines
22 KiB
TypeScript
import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
|
|
import { tmpdir } from "node:os";
|
|
import path from "node:path";
|
|
import { createHash } from "node:crypto";
|
|
import { expect, it } from "vitest";
|
|
import { appendCampaignCleanupResolution, campaignCleanupResolved, campaignRevalidationIdentity, campaignSummary, completeCampaignAttempt, freezeChatCampaign, reserveCampaignAttempt, validateFrozenCampaign, type CampaignAttempt, campaignProductIdentityEligible, type CampaignPublishedIdentity, campaignAttemptProcessed } from "./chat-campaign.js";
|
|
const root = new URL("../../", import.meta.url).pathname;
|
|
const base = "8373d7867963674ff960d2345d0d28086f799bc7";
|
|
it("resolves only complete hash-bound later resource absence without rewriting the original failure", () => {
|
|
const directory = mkdtempSync(path.join(tmpdir(), "chat-cleanup-resolution-"));
|
|
try {
|
|
const prefix = "tests/runner-e2e/results/cleanup-fixture/";
|
|
mkdirSync(path.join(directory, prefix), { recursive: true });
|
|
const save = (name: string, value: unknown) => {
|
|
const text = JSON.stringify(value); const relative = prefix + name;
|
|
writeFileSync(path.join(directory, relative), text);
|
|
return { path: relative, sha256: createHash("sha256").update(text).digest("hex") };
|
|
};
|
|
const a = attempt(1, "fixture-execution"); a.outcome = "failed"; a.cleanup = "failed"; a.finishedAt = a.startedAt;
|
|
const ownership = save("owned.json", { executionId: a.executionId, ordinal: 1, kind: "container", id: "owned-container", owned: true, nonce: "fixture-nonce" });
|
|
const noResources = (scope: string) => save(`${scope}-not-admitted.json`, { executionId: a.executionId, ordinal: 1, scope, notAdmitted: true, observedAt: a.startedAt });
|
|
const original = save("original.json", { schemaVersion: 1, kind: "campaign-admitted-resource-inventory", executionId: a.executionId, ordinal: 1, recordedAt: a.startedAt, cleanup: "failed",
|
|
resources: [{ kind: "container", id: "owned-container", ownershipEvidence: ownership }], notAdmittedScopes: { processes: noResources("processes"), proxy: noResources("proxy") } });
|
|
a.evidencePaths = [original.path];
|
|
const observedAt = new Date(Date.parse(a.startedAt) + 1000).toISOString();
|
|
const absence = save("absence.json", { kind: "container", id: "owned-container", absent: true, ownershipEvidenceSha256: ownership.sha256, observedAt });
|
|
const inventory = save("inventory.json", { executionId: a.executionId, ordinal: 1, complete: true, completeScopes: ["processes", "database", "proxy"],
|
|
resources: [{ kind: "container", id: "owned-container", ownershipEvidence: ownership }] });
|
|
const body = { schemaVersion: 1, executionId: a.executionId, ordinal: 1, originalCleanup: "failed", observedAt, verifierSourceRevision: base,
|
|
originalEvidence: original, inventory, resources: [{ kind: "container", id: "owned-container", absenceEvidence: absence }] };
|
|
const closed = save("resolution.json", body); const resolution = { at: observedAt, receiptPath: closed.path, receiptSha256: closed.sha256 };
|
|
const before = JSON.stringify(a);
|
|
expect(campaignCleanupResolved(a, directory)).toBe(false);
|
|
appendCampaignCleanupResolution(a, resolution, directory);
|
|
expect(campaignCleanupResolved(a, directory)).toBe(true);
|
|
const { cleanupResolutions: _, ...unchanged } = a;
|
|
expect(JSON.stringify(unchanged)).toBe(before);
|
|
expect(() => appendCampaignCleanupResolution(a, resolution, directory)).toThrow("distinct");
|
|
for (const wrong of [
|
|
{ ...body, executionId: "foreign" }, { ...body, resources: [] },
|
|
{ ...body, inventory: save("partial.json", { executionId: a.executionId, ordinal: 1, complete: false, resources: [] }) },
|
|
{ ...body, inventory: save("empty.json", { executionId: a.executionId, ordinal: 1, complete: true, completeScopes: ["processes", "database", "proxy"], resources: [] }), resources: [] },
|
|
{ ...body, resources: [{ kind: "container", id: "foreign", absenceEvidence: absence }] },
|
|
]) {
|
|
const ref = save("wrong.json", wrong);
|
|
expect(campaignCleanupResolved({ ...a, cleanupResolutions: [{ at: observedAt, receiptPath: ref.path, receiptSha256: ref.sha256 }] }, directory)).toBe(false);
|
|
}
|
|
const foreignOwnership = save("foreign-owned.json", { executionId: "foreign", ordinal: 1, kind: "container", id: "owned-container", owned: true });
|
|
const foreignOriginal = save("foreign-original.json", { schemaVersion: 1, kind: "campaign-admitted-resource-inventory", executionId: a.executionId, ordinal: 1, recordedAt: a.startedAt, cleanup: "failed",
|
|
resources: [{ kind: "container", id: "owned-container", ownershipEvidence: foreignOwnership }], notAdmittedScopes: { processes: noResources("processes"), proxy: noResources("proxy") } });
|
|
const foreignInventory = save("foreign-inventory.json", { executionId: a.executionId, ordinal: 1, complete: true, completeScopes: ["processes", "database", "proxy"], resources: [{ kind: "container", id: "owned-container", ownershipEvidence: foreignOwnership }] });
|
|
const foreignResolution = save("foreign-resolution.json", { ...body, originalEvidence: foreignOriginal, inventory: foreignInventory });
|
|
expect(campaignCleanupResolved({ ...a, evidencePaths: [foreignOriginal.path], cleanupResolutions: [{ at: observedAt, receiptPath: foreignResolution.path, receiptSha256: foreignResolution.sha256 }] }, directory)).toBe(false);
|
|
writeFileSync(path.join(directory, absence.path), JSON.stringify({ absent: false }));
|
|
expect(campaignCleanupResolved(a, directory)).toBe(false);
|
|
} finally { rmSync(directory, { recursive: true, force: true }); }
|
|
});
|
|
function attempt(ordinal: 1 | 2, executionId: string): CampaignAttempt {
|
|
return { productIdentity: { kind: "source-build", productionSourceRevision: base, snapshotSourceRevision: base, nativeBinarySha256: "a".repeat(64), workspaceBuildDigest: "b".repeat(64), receiptPaths: ["tests/runner-e2e/results/fixture/source-receipt.json"], coreCandidate: false }, ordinal, outcome: "running", executionId, startedAt: new Date().toISOString(), finishedAt: null,
|
|
sourceRevision: base, workingTreeDigest: "fixture", definitionDigest: "fixture", suiteDefinitionDigest: "fixture", graderDigest: "fixture",
|
|
model: "fixture", profile: "fixture", environment: "local", automaticRetries: 0,
|
|
correction: ordinal === 2 ? "Demonstrated fixture defect corrected" : null, classification: null, observedFailure: null,
|
|
evidencePaths: [], usage: { costUsd: null, coverage: "unknown", tokens: null }, cleanup: "pending", corePrDependencies: [] };
|
|
}
|
|
it("freezes all intended requests and keeps unrun scenarios in the denominator", () => {
|
|
const campaign = freezeChatCampaign(root, base);
|
|
expect(campaign.scenarios).toHaveLength(244);
|
|
expect(campaign.areas).toBe(35);
|
|
expect(campaign.capabilities).toBe(191);
|
|
expect(campaign.scenarios.every(scenario => scenario.query && scenario.context && scenario.expected_outcome)).toBe(true);
|
|
expect(campaignSummary(campaign)).toMatchObject({ denominator: 244, unrun: 244, finalPassed: 0, requiredPasses: 196, mergeEligible: false });
|
|
});
|
|
it("preserves failures and enforces one correction cycle with no retries after passing", () => {
|
|
const scenario = freezeChatCampaign(root, base).scenarios.find(scenario => scenario.id === "tasks.create-backlog")!;
|
|
const first = attempt(1, scenario.executionId!);
|
|
reserveCampaignAttempt(scenario, first);
|
|
expect(() => reserveCampaignAttempt(scenario, attempt(2, scenario.executionId!))).toThrow("still running");
|
|
first.outcome = "failed";
|
|
expect(() => reserveCampaignAttempt(scenario, { ...attempt(2, scenario.executionId!), correction: null })).toThrow("recorded correction");
|
|
const second = attempt(2, scenario.executionId!);
|
|
reserveCampaignAttempt(scenario, second);
|
|
second.outcome = "passed";
|
|
expect(scenario.attempts[0]!.outcome).toBe("failed");
|
|
expect(() => reserveCampaignAttempt(scenario, attempt(2, scenario.executionId!))).toThrow("budget exhausted");
|
|
const fresh = freezeChatCampaign(root, base).scenarios.find(scenario => scenario.id === "tasks.create-backlog")!;
|
|
const pass = attempt(1, fresh.executionId!);
|
|
reserveCampaignAttempt(fresh, pass); pass.outcome = "passed";
|
|
expect(() => reserveCampaignAttempt(fresh, attempt(2, fresh.executionId!))).toThrow("cannot be rerun");
|
|
});
|
|
it("excludes unmerged core-dependent and unclean results from the merge numerator", () => {
|
|
const campaign = freezeChatCampaign(root, base);
|
|
const scenario = campaign.scenarios.find(scenario => scenario.id === "tasks.create-backlog")!;
|
|
scenario.qualifyingDefinitionDigest = "fixture"; scenario.qualifyingGraderDigest = "fixture";
|
|
const result = attempt(1, scenario.executionId!); reserveCampaignAttempt(scenario, result);
|
|
result.outcome = "passed";
|
|
expect(campaignSummary(campaign).finalPassed).toBe(0);
|
|
result.cleanup = "passed"; result.corePrDependencies = ["https://github.com/example/core/pull/1"];
|
|
expect(campaignSummary(campaign).finalPassed).toBe(0);
|
|
result.corePrDependencies = [];
|
|
expect(campaignSummary(campaign).finalPassed).toBe(1);
|
|
scenario.qualifyingDefinitionDigest = "new revision";
|
|
expect(campaignSummary(campaign).finalPassed).toBe(0);
|
|
});
|
|
|
|
it("rejects missing evidence and definition drift before accepting a retained outcome", () => {
|
|
const campaign = freezeChatCampaign(root, base);
|
|
const scenario = campaign.scenarios.find(scenario => scenario.id === "tasks.create-backlog")!;
|
|
scenario.qualifyingDefinitionDigest = "fixture"; scenario.qualifyingGraderDigest = "fixture";
|
|
const reserved = attempt(1, scenario.executionId!); reserveCampaignAttempt(scenario, reserved);
|
|
const completion = { outcome: "passed" as const, finishedAt: new Date().toISOString(), definitionDigest: "fixture", graderDigest: "fixture",
|
|
evidencePaths: [] as string[], cleanup: "passed" as const, usage: reserved.usage, classification: null, observedFailure: null, corePrDependencies: [] };
|
|
expect(() => completeCampaignAttempt(scenario, completion)).toThrow("requires evidence");
|
|
expect(() => completeCampaignAttempt(scenario, { ...completion, definitionDigest: "changed" })).toThrow("changed during attempt");
|
|
expect(() => completeCampaignAttempt(scenario, { ...completion, evidencePaths: ["tests/runner-e2e/results/../private.json"] })).toThrow("sanitized result paths");
|
|
completeCampaignAttempt(scenario, { ...completion, evidencePaths: ["tests/runner-e2e/results/fixture/result.json"] });
|
|
expect(campaignSummary(campaign).finalPassed).toBe(1);
|
|
scenario.qualifyingDefinitionDigest = "new revision";
|
|
expect(campaignSummary(campaign).finalPassed).toBe(0);
|
|
});
|
|
|
|
it("detects catalog tampering while permitting honest readiness and ownership updates", () => {
|
|
const campaign = freezeChatCampaign(root, base);
|
|
campaign.scenarios[0]!.owner = "another-worker";
|
|
campaign.scenarios[0]!.blocker = "external prerequisite missing";
|
|
expect(() => validateFrozenCampaign(campaign, root)).not.toThrow();
|
|
campaign.scenarios[0]!.expected_outcome = "A weaker outcome";
|
|
expect(() => validateFrozenCampaign(campaign, root)).toThrow("Frozen scenario content changed");
|
|
});
|
|
|
|
it("does not turn partial implementations or automatic retries into valid campaign attempts", () => {
|
|
const scenario = freezeChatCampaign(root, base).scenarios.find(scenario => scenario.id === "tasks.create-backlog")!;
|
|
scenario.readiness = "partial";
|
|
expect(() => reserveCampaignAttempt(scenario, attempt(1, scenario.executionId!))).toThrow("no executable implementation");
|
|
scenario.readiness = "implemented";
|
|
const invalid = { ...attempt(1, scenario.executionId!), automaticRetries: 1 } as unknown as CampaignAttempt;
|
|
expect(() => reserveCampaignAttempt(scenario, invalid)).toThrow("Invalid attempt reservation");
|
|
expect(scenario.attempts).toHaveLength(0);
|
|
});
|
|
|
|
it("gates source acceptance on actual baseline/build receipts, not merely test source revision", () => {
|
|
const campaign = freezeChatCampaign(root, base), scenario = campaign.scenarios.find(s => s.id === "tasks.create-backlog")!;
|
|
const valid = attempt(1, scenario.executionId!);
|
|
expect(campaignProductIdentityEligible(scenario, valid, base)).toBe(true);
|
|
expect(campaignProductIdentityEligible(scenario, { ...valid, productIdentity: undefined }, base)).toBe(false);
|
|
for (const delta of [{ productionSourceRevision: "c".repeat(40) }, { nativeBinarySha256: "" }, { snapshotSourceRevision: "d".repeat(40) }, { coreCandidate: true }, { receiptPaths: [] }]) {
|
|
const product = { ...valid.productIdentity!, ...delta } as CampaignAttempt["productIdentity"];
|
|
expect(campaignProductIdentityEligible(scenario, { ...valid, productIdentity: product }, base)).toBe(false);
|
|
}
|
|
});
|
|
it("admits declared published operator transitions but rejects wrong observed targets and arbitrary installed substitution", () => {
|
|
const campaign = freezeChatCampaign(root, base), scenario = campaign.scenarios.find(s => s.id === "instance-operations.update-instance")!;
|
|
const publication = (version: string, h: string): CampaignPublishedIdentity => ({ version, treeSha256: h.repeat(64), artifacts: ["paperclipai", "@paperclipai/server"].map(name => ({ package: name as "paperclipai" | "@paperclipai/server", version, integrity: "sha512-YWJj", entrySha256: h.repeat(64) })) });
|
|
const source = publication("1.0.0", "a"), target = publication("1.0.1", "b");
|
|
const valid: CampaignAttempt = { ...attempt(1, "installed"), productIdentity: { kind: "published-release", declaredLane: "published-global-npm", source, target, observed: target, receiptPaths: ["tests/runner-e2e/results/fixture/installed.json"], coreCandidate: false } };
|
|
expect(campaignProductIdentityEligible(scenario, valid, base)).toBe(true);
|
|
expect(campaignProductIdentityEligible(scenario, { ...valid, productIdentity: { ...valid.productIdentity as Extract<CampaignAttempt["productIdentity"], { kind: "published-release" }>, observed: source } }, base)).toBe(false);
|
|
const unrelated = campaign.scenarios.find(s => s.id === "tasks.create-backlog")!;
|
|
expect(campaignProductIdentityEligible(unrelated, valid, base)).toBe(false);
|
|
expect(campaignProductIdentityEligible({ ...scenario, productPolicy: undefined }, valid, base)).toBe(false);
|
|
expect(campaignProductIdentityEligible(scenario, { ...valid, corePrDependencies: ["unmerged-core"] }, base)).toBe(false);
|
|
const boundary = campaign.scenarios.find(s => s.id === "onboarding.new-instance")!;
|
|
const installed = { ...valid, productIdentity: { kind: "published-release" as const, declaredLane: "empty-installed-boundary" as const, source, observed: source, receiptPaths: ["tests/runner-e2e/results/fixture/published-boundary.json"], coreCandidate: false } };
|
|
expect(campaignProductIdentityEligible(boundary, installed, base)).toBe(true);
|
|
const sourceBuilt = { ...attempt(1, "boundary"), productIdentity: { kind: "source-built-installed" as const, productionSourceRevision: base, snapshotSourceRevision: base, nativeBinarySha256: "a".repeat(64), workspaceBuildDigest: "b".repeat(64), cliSha256: "c".repeat(64), serverSha256: "d".repeat(64), artifactTreeSha256: "e".repeat(64), receiptPaths: ["tests/runner-e2e/results/fixture/source-pack.json"], coreCandidate: false } };
|
|
expect(campaignProductIdentityEligible(boundary, sourceBuilt, base)).toBe(true);
|
|
expect(campaignProductIdentityEligible(scenario, sourceBuilt, base)).toBe(false);
|
|
});
|
|
it("does not complete or report a qualifying pass when its product identity is missing", () => {
|
|
const campaign = freezeChatCampaign(root, base), scenario = campaign.scenarios.find(s => s.id === "tasks.create-backlog")!;
|
|
const reserved = attempt(1, scenario.executionId!); reserved.productIdentity = undefined;
|
|
reserveCampaignAttempt(scenario, reserved);
|
|
scenario.qualifyingDefinitionDigest = "fixture"; scenario.qualifyingGraderDigest = "fixture";
|
|
const completion = { outcome: "passed" as const, finishedAt: new Date().toISOString(), definitionDigest: "fixture", graderDigest: "fixture", evidencePaths: ["tests/runner-e2e/results/fixture/result.json"], cleanup: "passed" as const, usage: reserved.usage, classification: null, observedFailure: null, corePrDependencies: [] };
|
|
expect(() => completeCampaignAttempt(scenario, completion)).toThrow("eligible product identity");
|
|
Object.assign(reserved, completion);
|
|
expect(campaignSummary(campaign)).toMatchObject({ initialPassed: 0, finalPassed: 0, productEvidence: { identityIneligibleMeasurements: 1, measurementsByIdentity: { unknown: 1 } } });
|
|
});
|
|
|
|
it("processes concrete unsupported probes without accepting incomplete outcomes or unfinished shells", () => {
|
|
const campaign = freezeChatCampaign(root, base), scenario = campaign.scenarios.find(s => s.id === "tasks.create-backlog")!;
|
|
scenario.readiness = "partial"; scenario.authoringStatus = "concrete-blocker";
|
|
scenario.blockerProbeSources = ["chat-catalog-domains/identity-access-grants.ts"];
|
|
const a = attempt(1, scenario.executionId!); reserveCampaignAttempt(scenario, a);
|
|
const completion = { outcome: "passed" as const, finishedAt: new Date().toISOString(), definitionDigest: "fixture", graderDigest: "fixture", evidencePaths: ["tests/runner-e2e/results/fixture/result.json"], cleanup: "passed" as const, usage: a.usage, classification: null, observedFailure: null, corePrDependencies: [] };
|
|
expect(() => completeCampaignAttempt(scenario, completion)).toThrow("Incomplete conditions");
|
|
completeCampaignAttempt(scenario, { ...completion, outcome: "blocked" });
|
|
expect(campaignSummary(campaign)).toMatchObject({ authored: 2, coverageComplete: 1, concreteBlockers: 1, unfinished: 0, authoringResolved: 2, processed: 0, finalPassed: 0, mergeEligible: false });
|
|
scenario.authoringStatus = "unfinished"; scenario.attempts = [];
|
|
expect(() => reserveCampaignAttempt(scenario, attempt(1, scenario.executionId!))).toThrow("no executable implementation");
|
|
expect(campaignSummary(campaign)).toMatchObject({ unfinished: 1, authoringResolved: 1 });
|
|
});
|
|
it("requires a real terminal source-attributed result for processing, not a reservation or calibration receipt", () => {
|
|
const temporary = mkdtempSync(path.join(tmpdir(), "chat-campaign-processing-"));
|
|
try {
|
|
const a = attempt(1, "chat-features.runner-codex-subscription.local.fixture");
|
|
a.outcome = "blocked"; a.finishedAt = new Date().toISOString();
|
|
const relative = "tests/runner-e2e/results/owned/result.json", filename = path.join(temporary, relative);
|
|
a.evidencePaths = [relative]; mkdirSync(path.dirname(filename), { recursive: true });
|
|
expect(campaignAttemptProcessed(a, temporary)).toBe(false);
|
|
const raw = { executionId: a.executionId, source: { sha: a.sourceRevision }, status: "failed", startedAt: a.startedAt, finishedAt: a.finishedAt };
|
|
writeFileSync(filename, JSON.stringify(raw)); expect(campaignAttemptProcessed(a, temporary)).toBe(true);
|
|
writeFileSync(filename, JSON.stringify({ ...raw, source: { sha: "wrong" } })); expect(campaignAttemptProcessed(a, temporary)).toBe(false);
|
|
writeFileSync(filename, JSON.stringify({ calibration: true })); expect(campaignAttemptProcessed(a, temporary)).toBe(false);
|
|
} finally { rmSync(temporary, { recursive: true, force: true }); }
|
|
});
|
|
|
|
it("permits a processed unsupported remainder while requiring every unfinished branch to close", () => {
|
|
const temporary = mkdtempSync(path.join(tmpdir(), "chat-campaign-gate-"));
|
|
try {
|
|
const campaign = freezeChatCampaign(root, base); let passes = 0;
|
|
for (const [index, s] of campaign.scenarios.entries()) {
|
|
s.readiness = "implemented"; s.authoringStatus = "complete"; s.executionId = `chat-features.runner-codex-subscription.local.${s.id}`;
|
|
s.qualifyingDefinitionDigest = "fixture"; s.qualifyingGraderDigest = "fixture";
|
|
const a = attempt(1, s.executionId); a.finishedAt = a.startedAt; a.cleanup = "passed";
|
|
a.outcome = s.productPolicy?.lane === "source-build" && passes < 196 ? "passed" : "blocked";
|
|
if (a.outcome === "passed") passes++;
|
|
const relative = `tests/runner-e2e/results/gate-${index}/result.json`, filename = path.join(temporary, relative);
|
|
mkdirSync(path.dirname(filename), { recursive: true });
|
|
writeFileSync(filename, JSON.stringify({ executionId: a.executionId, source: { sha: a.sourceRevision }, status: a.outcome === "passed" ? "passed" : "failed", startedAt: a.startedAt, finishedAt: a.finishedAt }));
|
|
a.evidencePaths = [relative]; s.attempts.push(a);
|
|
}
|
|
const blocked = campaign.scenarios.find(s => s.attempts[0]!.outcome === "blocked")!;
|
|
blocked.readiness = "partial"; blocked.authoringStatus = "concrete-blocker"; blocked.blockerProbeSources = ["actual-supported-surface-probe.ts"];
|
|
expect(campaignSummary(campaign, temporary)).toMatchObject({ authoringResolved: 244, processed: 244, finalPassed: 196, mergeEligible: true });
|
|
blocked.authoringStatus = "unfinished";
|
|
expect(campaignSummary(campaign, temporary)).toMatchObject({ authoringResolved: 243, unfinished: 1, mergeEligible: false });
|
|
} finally { rmSync(temporary, { recursive: true, force: true }); }
|
|
});
|
|
|
|
it("permits exactly one recorded final revalidation only after an actual selected qualifying identity change", () => {
|
|
const scenario = freezeChatCampaign(root, base).scenarios.find(x => x.id === "tasks.create-backlog")!, first = attempt(1, scenario.executionId!);
|
|
reserveCampaignAttempt(scenario, first); first.outcome = "passed"; const original = JSON.stringify(first);
|
|
const next = attempt(2, scenario.executionId!); next.sourceRevision = "c".repeat(40);
|
|
next.passedRevalidation = { reason: "Shared selected closure changed for final baseline", previous: campaignRevalidationIdentity(first), next: campaignRevalidationIdentity(next) };
|
|
scenario.qualifyingDefinitionDigest = next.definitionDigest; scenario.qualifyingGraderDigest = next.graderDigest;
|
|
expect(() => reserveCampaignAttempt(scenario, next)).toThrow("actual qualifying identity invalidation");
|
|
next.definitionDigest = "actual-new-selected-closure"; scenario.qualifyingDefinitionDigest = next.definitionDigest;
|
|
next.passedRevalidation.next = campaignRevalidationIdentity(next); next.passedRevalidation.previous.definitionDigest = "invented-old";
|
|
expect(() => reserveCampaignAttempt(scenario, next)).toThrow("actual qualifying identity invalidation");
|
|
next.passedRevalidation.previous = campaignRevalidationIdentity(first); next.correction = null;
|
|
expect(() => reserveCampaignAttempt(scenario, next)).toThrow("recorded correction");
|
|
next.correction = "Coherent shared closure correction on final B"; reserveCampaignAttempt(scenario, next);
|
|
expect(JSON.stringify(first)).toBe(original); next.outcome = "failed";
|
|
expect(() => reserveCampaignAttempt(scenario, attempt(2, scenario.executionId!))).toThrow("budget exhausted");
|
|
});
|