test(cli): consolidate source Evidence finalization checks (#12861)

test(cli): consolidate completed source evidence finalization checks
This commit is contained in:
morluto authored and GitHub committed 2026-11-20 15:12:52 +00:00
1 parent d137ffa762
commit 688d129aef
1 file changed
+121 -196
+121 -196
View File
@@ -82,84 +82,6 @@ it.each(["inspect_macho", "inspect_managed_members"] as const)(
},
);
it("delivers a preexisting completed record inline after one-shot cleanup", async () => {
const provider = { id: "fixture", name: "Fixture", version: "1" };
const source = createEvidence(
unknownTarget("not-observed"),
provider,
{ operation: "health", parameters: {}, result: "large".repeat(20000) },
{ immutable: true },
);
const path = join(
await createTestTempDirectory("rea-oneshot-source-"),
"fixture.com",
);
await writeFile(path, Buffer.from([0xb8, 0, 0x4c, 0xcd, 0x21]));
const router = createTestProviderRouter(() => ({
execute: async (op) =>
ok(
createAnalysisExecution(
op === "health" ? null : "completed",
provider,
op === "health" ? {} : { sourceEvidence: [source] },
),
),
close: async () => ok(null),
}));
const records = new InvestigationRecords({
maximumRepresentationBytes: 20000,
});
const session = new BinarySession(router, records);
const opened = await session.open(path, { formatHint: "dos-com" });
if (!opened.ok) throw opened.error;
const args = { address: "0x100", length: 4 };
const primary = createAnalysisExecutionEvidence(
"read_bytes",
args,
{
...createAnalysisExecution("completed", provider, {
sourceEvidence: [source],
}),
subject: opened.value,
},
"observed",
);
expect(session.recordEvidence(primary).ok).toBe(true);
const create = () => session;
const dependencies: DirectAnalysisDependencies = {
readConfiguration: () => parseConfig({}),
createBinarySession: create,
createNativeDispatchBinarySession: create,
createArtifactBinarySession: create,
createNativeBinarySession: create,
createManagedBinarySession: create,
};
const result = await runDirectAnalysis(
dependencies,
path,
"read_bytes",
args,
{ formatHint: "dos-com" },
);
expect(result.ok).toBe(false);
if (result.ok) throw new Error("Expected source failure");
expect(result.error).toMatchObject({
code: "resource_constraint",
details: {
completed_observation: {
kind: "inline-evidence",
retention: "one-shot-session",
source_closure: "not-established",
evidence: {
evidence_id: primary.evidence_id,
caller_input_path: path,
normalized_result: "completed",
},
},
},
});
});
it("keeps caller spelling on a raw observation when a source ID is malformed", async () => {
const provider = { id: "fixture", name: "Fixture", version: "1" };
const base = createEvidence(unknownTarget("not-observed"), provider, {
@@ -168,11 +90,12 @@ it("keeps caller spelling on a raw observation when a source ID is malformed", a
result: "source",
});
const source = { ...base, evidence_id: "invalid" };
const path = join(
await createTestTempDirectory("rea-oneshot-invalid-source-"),
"fixture.com",
const root = await createTestTempDirectory("rea-oneshot-invalid-source-");
const path = `${root}/./fixture.com`;
await writeFile(
join(root, "fixture.com"),
Buffer.from([0xb8, 0, 0x4c, 0xcd, 0x21]),
);
await writeFile(path, Buffer.from([0xb8, 0, 0x4c, 0xcd, 0x21]));
const router = createTestProviderRouter(() => ({
execute: async (op) =>
ok(
@@ -219,134 +142,136 @@ it("keeps caller spelling on a raw observation when a source ID is malformed", a
});
});
it.each([false, true])(
"keeps the source failure and primary when cancellation arrives during final close (close fails: %s)",
async (closeFails) => {
const provider = { id: "fixture", name: "Fixture", version: "1" };
const source = createEvidence(
unknownTarget("not-observed"),
provider,
{ operation: "health", parameters: {}, result: "large".repeat(20000) },
{ immutable: true },
);
const path = join(
await createTestTempDirectory("rea-source-final-close-"),
"fixture.com",
);
await writeFile(path, Buffer.from([0xb8, 0, 0x4c, 0xcd, 0x21]));
const session = new BinarySession(
createTestProviderRouter(() => ({
execute: async (op) =>
ok(
createAnalysisExecution(
op === "health" ? null : "completed",
provider,
op === "health" ? {} : { sourceEvidence: [source] },
),
it.each([
"ordinary close",
"cancelled close",
"cancelled close with retained resources",
] as const)("delivers the completed record inline after %s", async (finish) => {
const cancelled = finish !== "ordinary close";
const closeFails = finish === "cancelled close with retained resources";
const provider = { id: "fixture", name: "Fixture", version: "1" };
const source = createEvidence(
unknownTarget("not-observed"),
provider,
{ operation: "health", parameters: {}, result: "large".repeat(20000) },
{ immutable: true },
);
const path = join(
await createTestTempDirectory("rea-source-final-close-"),
"fixture.com",
);
await writeFile(path, Buffer.from([0xb8, 0, 0x4c, 0xcd, 0x21]));
const session = new BinarySession(
createTestProviderRouter(() => ({
execute: async (op) =>
ok(
createAnalysisExecution(
op === "health" ? null : "completed",
provider,
op === "health" ? {} : { sourceEvidence: [source] },
),
close: async () => ok(null),
})),
new InvestigationRecords({ maximumRepresentationBytes: 20000 }),
);
const opened = await session.open(path, { formatHint: "dos-com" });
if (!opened.ok) throw opened.error;
const args = { address: "0x100", length: 4 };
const primary = createAnalysisExecutionEvidence(
),
close: async () => ok(null),
})),
new InvestigationRecords({ maximumRepresentationBytes: 20000 }),
);
const opened = await session.open(path, { formatHint: "dos-com" });
if (!opened.ok) throw opened.error;
const args = { address: "0x100", length: 4 };
const primary = createAnalysisExecutionEvidence(
"read_bytes",
args,
{
...createAnalysisExecution("completed", provider, {
sourceEvidence: [source],
}),
subject: opened.value,
},
"observed",
);
expect(session.recordEvidence(primary).ok).toBe(true);
const create = () => session;
const dependencies: DirectAnalysisDependencies = {
readConfiguration: () => parseConfig({}),
createBinarySession: create,
createNativeDispatchBinarySession: create,
createArtifactBinarySession: create,
createNativeBinarySession: create,
createManagedBinarySession: create,
};
const controller = new AbortController();
const reason = { during: "final close" };
const recordEvidence = vi.spyOn(session, "recordEvidence");
const nativeClose = session.close.bind(session);
const failure = new ProviderCleanupError("fixture", ["fixture-owner"], {});
const close = vi.spyOn(session, "close").mockImplementationOnce(async () => {
if (cancelled) controller.abort(reason);
return closeFails ? err(failure) : nativeClose();
});
try {
const result = await runDirectAnalysis(
dependencies,
path,
"read_bytes",
args,
{
...createAnalysisExecution("completed", provider, {
sourceEvidence: [source],
}),
subject: opened.value,
formatHint: "dos-com",
signal: controller.signal,
},
"observed",
);
expect(session.recordEvidence(primary).ok).toBe(true);
const create = () => session;
const dependencies: DirectAnalysisDependencies = {
readConfiguration: () => parseConfig({}),
createBinarySession: create,
createNativeDispatchBinarySession: create,
createArtifactBinarySession: create,
createNativeBinarySession: create,
createManagedBinarySession: create,
};
const controller = new AbortController();
const reason = { during: "final close" };
const recordEvidence = vi.spyOn(session, "recordEvidence");
const nativeClose = session.close.bind(session);
const failure = new ProviderCleanupError("fixture", ["fixture-owner"], {});
const close = vi
.spyOn(session, "close")
.mockImplementationOnce(async () => {
controller.abort(reason);
return closeFails ? err(failure) : nativeClose();
});
try {
const result = await runDirectAnalysis(
dependencies,
path,
"read_bytes",
args,
{
formatHint: "dos-com",
signal: controller.signal,
if (result.ok) throw new Error("Expected source failure");
expect(result.error).toMatchObject({
code: closeFails ? "cleanup_incomplete" : "resource_constraint",
details: {
partial_observation: {
kind: "unretained-evidence",
evidence: { evidence_id: source.evidence_id },
},
);
expect(result.ok).toBe(false);
if (result.ok) throw new Error("Expected source failure");
expect(result.error).toMatchObject({
code: closeFails ? "cleanup_incomplete" : "resource_constraint",
details: {
partial_observation: {
kind: "unretained-evidence",
evidence: { evidence_id: source.evidence_id },
completed_observation: {
kind: "inline-evidence",
retention: "one-shot-session",
source_closure: "not-established",
evidence: {
evidence_id: primary.evidence_id,
caller_input_path: path,
normalized_result: "completed",
},
completed_observation: {
kind: "inline-evidence",
retention: "one-shot-session",
source_closure: "not-established",
evidence: {
evidence_id: primary.evidence_id,
caller_input_path: path,
normalized_result: "completed",
},
},
...(closeFails
? {
resources: ["fixture-owner"],
cleanup: "incomplete",
execution_failure: "resource_constraint",
}
: {}),
},
});
const sourceFailure = recordEvidence.mock.results
.map(({ value }) => value)
.find((value) => value !== undefined && !value.ok);
expect(sourceFailure).toBeDefined();
expect(
primaryAnalysisError(sourceFailure!.error).secondaryFailures.some(
(failure) =>
failure instanceof AnalysisCancelledError &&
failure.cause === reason,
),
).toBe(true);
...(closeFails
? {
resources: ["fixture-owner"],
cleanup: "incomplete",
execution_failure: "resource_constraint",
}
: {}),
},
});
const sourceFailure = recordEvidence.mock.results
.map(({ value }) => value)
.find((value) => value !== undefined && !value.ok);
if (sourceFailure === undefined)
throw new Error("Expected a source recording failure");
expect(
primaryAnalysisError(sourceFailure.error).secondaryFailures.some(
(failure) =>
failure instanceof AnalysisCancelledError && failure.cause === reason,
),
).toBe(cancelled);
if (cancelled)
expect(result.error).toMatchObject({
details: {
secondary_failures: [expect.objectContaining({ code: "cancelled" })],
},
});
expect(session.activeTarget() !== undefined).toBe(closeFails);
} finally {
close.mockRestore();
const closed = await nativeClose();
if (!closed.ok) throw closed.error;
expect(session.activeTarget()).toBeUndefined();
}
},
);
else expect(result.error).not.toHaveProperty("details.secondary_failures");
expect(session.activeTarget() !== undefined).toBe(closeFails);
} finally {
close.mockRestore();
const closed = await nativeClose();
if (!closed.ok) throw closed.error;
expect(session.activeTarget()).toBeUndefined();
}
});
it.each([false, true])(
"preserves admission omission during final-close cancellation (close fails: %s)",