test(evidence): verify request admission and retained display ownership (#13053)

* test(evidence): verify frame refusal and pre-parse cancellation

* test(evidence): verify display and digest at their owners
This commit is contained in:
morluto authored and GitHub committed 2026-11-21 09:07:28 +00:00
1 parent cf87e474eb
commit 0c3e1d69aa
4 files changed
+51 -63

No files matched your search

@@ -173,8 +173,16 @@ describe("schema-owned Evidence request resolution", () => {
},
schema,
);
if (rejected.ok) throw new Error("invalid envelope was admitted");
expect(rejected.error).toBeInstanceOf(AnalysisInputError);
expect(rejected).toMatchObject({
ok: false,
error: {
_tag: "AnalysisInputError",
issues: [
expect.objectContaining({ path: ["sources"] }),
expect.objectContaining({ path: ["limit"] }),
],
},
});
});
});
@@ -337,20 +345,24 @@ describe("Evidence request borrowing and cancellation", () => {
const controller = new AbortController();
const reason = new Error("cancelled by caller");
controller.abort(reason);
let lookups = 0;
const schema = z
.strictObject({ source: evidenceInputSchema })
.superRefine(() => {
throw new Error("Cancelled request reached input parsing");
});
const result = resolveEvidenceRequest(
"test",
{ source: reference },
z.strictObject({ source: evidenceInputSchema }),
schema,
() => {
lookups += 1;
return evidence;
throw new Error("Cancelled request reached source lookup");
},
{ signal: controller.signal },
);
if (result.ok) throw new Error("cancelled request was admitted");
expect(result.error.cause).toBe(reason);
expect(lookups).toBe(0);
expect(result).toMatchObject({
ok: false,
error: { _tag: "AnalysisCancelledError", cause: reason },
});
});
it("observes cancellation raised by the final source owner", () => {
@@ -190,9 +190,9 @@ it.each(["inline", "retained-evidence", "invalid"] as const)(
},
);
it.each([false, true])(
"summarizes the selected observation path rather than older retained display metadata (history=%s)",
(history) => {
it.each(["new observation", "changed path", "changed name"] as const)(
"summarizes selected display metadata for %s",
(scenario) => {
const makeParent = (path: string) =>
createEvidence(
{ path, format: "pe", sha256: "c".repeat(64) },
@@ -204,21 +204,29 @@ it.each([false, true])(
},
);
const previous = makeParent("/old/fixture.exe");
const selected = makeParent("/selected/fixture.exe");
const selected =
scenario === "changed name"
? rebindEvidenceToTargetPath(previous, {
...fileSubjectTarget(previous.subject),
name: "selected display",
})
: makeParent("/selected/fixture.exe");
expect(selected.evidence_id).toBe(previous.evidence_id);
const ledger = new EvidenceLedger();
if (history) expect(ledger.record(previous).ok).toBe(true);
if (scenario !== "new observation")
expect(ledger.record(previous).ok).toBe(true);
const summary = summarizeRetainedAnalysis(selected, {
recordEvidence: (evidence) => ledger.record(evidence),
evidenceById: (id) => ledger.forAnalysis(id),
});
if (!summary.ok) throw summary.error;
expect(summary.value.evidence_links).toEqual([selected.evidence_id]);
expect(summary.value.subject?.local_path).toBe(
selected.subject?.local_path,
);
expect(ledger.get(selected.evidence_id)?.subject?.local_path).toBe(
history ? previous.subject?.local_path : selected.subject?.local_path,
expect(summary.value.subject).toEqual({
...selected.subject,
name: scenario === "changed name" ? "selected display" : "fixture.exe",
});
expect(ledger.get(selected.evidence_id)?.subject).toEqual(
scenario === "new observation" ? selected.subject : previous.subject,
);
},
);
@@ -2,17 +2,10 @@ import {
fileIdentity,
fileSubjectDisplay,
fileSubjectTarget,
displayedEvidenceSubject,
} from "../../../tests/fixtures/evidenceSubject.js";
import { expect, it, vi } from "vitest";
import {
createEvidence,
parseEvidence,
rebindEvidenceToTargetPath,
type Evidence,
} from "../../domain/evidence.js";
import { ok } from "../../domain/result.js";
import { createEvidence, type Evidence } from "../../domain/evidence.js";
import { createJavaScriptApplicationGraph } from "../../domain/javascript/javascriptApplicationGraph.js";
import { createJavaScriptSemanticGraph } from "../../domain/javascript/javascriptSemanticGraph.js";
import { javascriptApplicationAnalysisResultSchema } from "../../domain/javascript/javascriptApplicationAnalysis.js";
@@ -29,10 +22,7 @@ import {
} from "./JavaScriptApplicationWorkflowService.js";
import { reconcileJavaScriptRuntimeEvidence } from "./JavaScriptRuntimeReconciliationService.js";
import { traceJavaScriptSemanticsEvidence } from "./JavaScriptSemanticTraceService.js";
import {
inspectAnalysisView,
projectRetainedAnalysis,
} from "../analysisView/AnalysisViewService.js";
import { inspectAnalysisView } from "../analysisView/AnalysisViewService.js";
const reference = ({ evidence_id }: Evidence) => ({
kind: "retained-evidence" as const,
@@ -126,31 +116,6 @@ it("preserves the verified application subject in both trace workflows", async (
});
if (!view.ok) throw view.error;
expect(view.value.subject).toEqual(application.subject);
const selected = parseEvidence({
...feature.value.evidence,
subject: displayedEvidenceSubject(feature.value.evidence.subject, {
name: "selected display",
}),
});
const retained = projectRetainedAnalysis(
selected,
{
recordEvidence: () => ok("added"),
evidenceById: () => feature.value.evidence,
},
{ kind: "summary" },
);
if (!retained.ok) throw retained.error;
expect(retained.value.subject?.name).toBe("selected display");
expect(
rebindEvidenceToTargetPath(feature.value.evidence, {
path: fileSubjectDisplay(application.subject).local_path,
sha256: "f".repeat(64),
format: fileIdentity(application.subject).format,
architecture: "x86_64",
name: "wrong artifact",
}),
).toBe(feature.value.evidence);
});
it("does not attribute a multi-source reconciliation graph to its envelope subject", () => {
+10 -7
View File
@@ -84,13 +84,16 @@ describe("subject target identity", () => {
local_path: "/elsewhere/firmware.bin",
});
expect(rebound.evidence_id).toBe(original.evidence_id);
// A different selection is a different target, so the path is not rebound.
expect(
rebindEvidenceToTargetPath(original, {
...raw("0x100"),
path: "/elsewhere/firmware.bin",
}),
).toBe(original);
for (const different of [
raw("0x100"),
{ ...raw("0x0"), sha256: "f".repeat(64) },
])
expect(
rebindEvidenceToTargetPath(original, {
...different,
path: "/elsewhere/firmware.bin",
}),
).toBe(original);
});
it("names the subject only by its identity and display facts", () => {