test(javascript): consolidate graph and version comparison coverage

This commit is contained in:
morluto committed 2026-11-17 23:02:01 -05:00
1 parent 1881bbb55b
commit 025df6ec30
9 files changed
+747 -889

No files matched your search

@@ -84,7 +84,6 @@ describe("immutable JavaScript result reuse", () => {
});
else Object.defineProperty(input, "input_path", { enumerable: false });
freezeJsonSnapshot(input);
const expected = javascriptApplicationAnalysisResultSchema.parse(input);
for (let repeat = 0; repeat < 2; repeat += 1) {
const parsed = complete(
parseOwnedJavaScriptApplicationAnalysisSteps(input),
@@ -93,9 +92,8 @@ describe("immutable JavaScript result reuse", () => {
expect(Object.hasOwn(parsed, "not_in_parsed_result")).toBe(false);
expect(
Object.getOwnPropertyDescriptor(parsed, "input_path")?.enumerable,
).toBe(
Object.getOwnPropertyDescriptor(expected, "input_path")?.enumerable,
);
).toBe(true);
expect(parsed.input_path).toBe(input.input_path);
}
},
);
@@ -141,38 +139,49 @@ describe("immutable JavaScript result reuse", () => {
complete(parseOwnedJavaScriptApplicationAnalysisSteps(input)),
).not.toBe(input);
input.statistics.findings = -1;
expect(() =>
complete(parseOwnedJavaScriptApplicationAnalysisSteps(input)),
).toThrow(z.ZodError);
expect(
issuesFrom(() =>
complete(parseOwnedJavaScriptApplicationAnalysisSteps(input)),
),
).toMatchObject([{ path: ["statistics", "findings"] }]);
},
);
});
describe("owned JavaScript graph validation", () => {
it("reuses exact sealed graphs and preserves all public result fields", () => {
it("reuses exact sealed graphs and copies mutable imported graphs", () => {
const input = ownedExample();
const result = complete(
parseOwnedJavaScriptApplicationAnalysisSteps(input),
);
expect(result).toEqual(
javascriptApplicationAnalysisResultSchema.parse(input),
);
expect(result.graph).toBe(input.graph);
expect(result.semantic_graph).toBe(input.semantic_graph);
expect(result.summary).not.toBe(input.summary);
expect(result.statistics).not.toBe(input.statistics);
expect(
issuesFrom(() =>
complete(
parseOwnedJavaScriptApplicationAnalysisSteps({
...input,
extra: true,
}),
),
),
).toMatchObject([{ code: "unrecognized_keys", path: [], keys: ["extra"] }]);
expect(Object.isFrozen(result.graph.nodes[0]?.observations)).toBe(true);
expect(Object.isFrozen(result.semantic_graph.nodes[0]?.properties)).toBe(
true,
);
expect(isValidatedImmutableJavaScriptApplicationGraph(result.graph)).toBe(
true,
const imported = structuredClone(input);
const parsed = complete(
parseOwnedJavaScriptApplicationAnalysisSteps(imported),
);
expect(parsed).toEqual(result);
expect(parsed.graph).not.toBe(imported.graph);
expect(parsed.semantic_graph).not.toBe(imported.semantic_graph);
expect(
isValidatedImmutableJavaScriptSemanticGraph(result.semantic_graph),
).toBe(true);
expect(
isValidatedImmutableJavaScriptApplicationGraph(result.graph.nodes),
isValidatedImmutableJavaScriptSemanticGraph(parsed.semantic_graph),
).toBe(false);
});
@@ -201,41 +210,15 @@ describe("owned JavaScript graph validation", () => {
);
});
it.each(["mutable", "shallow-frozen", "json-sealed"])(
"fully validates %s imported graphs instead of trusting their IDs",
(representation) => {
const input = example();
input.graph.graph_id = `jag_${"f".repeat(64)}`;
if (representation === "shallow-frozen") Object.freeze(input.graph);
if (representation === "json-sealed") freezeJsonSnapshot(input.graph);
expect(isValidatedImmutableJavaScriptApplicationGraph(input.graph)).toBe(
false,
);
const issues = issuesFrom(() =>
complete(parseOwnedJavaScriptApplicationAnalysisSteps(input)),
);
expect(issues).toEqual(
issuesFrom(() =>
javascriptApplicationAnalysisResultSchema.parse(input),
),
);
expect(
issues.some(({ path }) => path.join("/") === "graph/graph_id"),
).toBe(true);
},
);
it("fully parses valid imported graphs without conferring an owned proof", () => {
it("does not trust a deeply frozen imported graph with a stale commitment", () => {
const input = example();
const parsed = complete(
parseOwnedJavaScriptApplicationAnalysisSteps(input),
);
expect(parsed).toEqual(input);
expect(parsed.graph).not.toBe(input.graph);
expect(parsed.semantic_graph).not.toBe(input.semantic_graph);
input.graph.limitations.push("A limitation added after commitment.");
freezeJsonSnapshot(input);
expect(
isValidatedImmutableJavaScriptSemanticGraph(parsed.semantic_graph),
).toBe(false);
issuesFrom(() =>
complete(parseOwnedJavaScriptApplicationAnalysisSteps(input)),
),
).toMatchObject([{ path: ["graph", "graph_id"] }]);
});
it("rejects a forged semantic graph paired with an authenticated application graph", () => {
@@ -244,16 +227,11 @@ describe("owned JavaScript graph validation", () => {
...input.semantic_graph,
graph_id: `jsrg_${"f".repeat(64)}`,
});
expect(
isValidatedImmutableJavaScriptSemanticGraph(input.semantic_graph),
).toBe(false);
expect(
issuesFrom(() =>
complete(parseOwnedJavaScriptApplicationAnalysisSteps(input)),
),
).toEqual(
issuesFrom(() => javascriptApplicationAnalysisResultSchema.parse(input)),
);
).toMatchObject([{ path: ["semantic_graph", "graph_id"] }]);
});
it("does not authenticate an abandoned sealing operation", () => {
@@ -307,15 +285,17 @@ describe("owned JavaScript result bindings", () => {
sealTransferredJavaScriptSemanticGraphSteps(semantic),
);
}
expect(
issuesFrom(() =>
complete(parseOwnedJavaScriptApplicationAnalysisSteps(input)),
),
).toEqual(
issuesFrom(() =>
javascriptApplicationAnalysisResultSchema.parse(input),
),
const bindingPath = {
application: ["semantic_graph", "application_graph_id"],
root: ["semantic_graph", "root_artifact_sha256"],
node: ["semantic_graph", "nodes"],
}[binding]!;
const issues = issuesFrom(() =>
complete(parseOwnedJavaScriptApplicationAnalysisSteps(input)),
);
expect(
issues.map(({ path }) => path.slice(0, bindingPath.length)),
).toContainEqual(bindingPath);
},
);
@@ -350,21 +330,6 @@ describe("owned JavaScript result bindings", () => {
issuesFrom(() => javascriptApplicationAnalysisResultSchema.parse(input)),
);
});
it("retains strict metadata validation alongside authenticated graphs", () => {
const input = {
...ownedExample(),
statistics: { ...example().statistics, findings: -1 },
extra: true,
};
expect(
issuesFrom(() =>
complete(parseOwnedJavaScriptApplicationAnalysisSteps(input)),
),
).toEqual(
issuesFrom(() => javascriptApplicationAnalysisResultSchema.parse(input)),
);
});
});
describe("graphs transferred to their sealing steps", () => {
@@ -424,39 +389,22 @@ describe("graphs transferred to their sealing steps", () => {
});
});
describe("skipped_javascript_files", () => {
it("refuses a result without the skipped counter", () => {
const withoutCounter = structuredClone(
JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE.normalized_result,
) as Record<string, unknown>;
const statistics = withoutCounter.statistics as Record<string, unknown>;
delete statistics.skipped_javascript_files;
expect(
javascriptApplicationAnalysisResultSchema.safeParse(withoutCounter).error
?.issues[0]?.path,
).toEqual(["statistics", "skipped_javascript_files"]);
});
it("keeps the producer-written skipped count in current evidence", () => {
const current = structuredClone(
JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE.normalized_result,
) as Record<string, unknown>;
const statistics = current.statistics as Record<string, unknown>;
statistics.skipped_javascript_files = 3;
const result = javascriptApplicationAnalysisResultSchema.parse(current);
expect(result.statistics.skipped_javascript_files).toBe(3);
});
});
describe("Electron boundary summary", () => {
it("refuses a summary without the protocol registration count", () => {
const current = example();
const { protocol_registrations: _count, ...summary } = current.summary;
expect(
javascriptApplicationAnalysisResultSchema.safeParse({
it("requires the published skipped-file and protocol registration counts", () => {
const current = example();
const { skipped_javascript_files: _skipped, ...statistics } =
current.statistics;
const { protocol_registrations: _protocols, ...summary } = current.summary;
expect(
javascriptApplicationAnalysisResultSchema
.safeParse({
...current,
statistics,
summary,
}).error?.issues[0]?.path,
).toEqual(["summary", "protocol_registrations"]);
});
})
.error?.issues.map(({ path }) => path.join("/"))
.sort(),
).toEqual([
"statistics/skipped_javascript_files",
"summary/protocol_registrations",
]);
});
@@ -5,10 +5,12 @@ import {
createJavaScriptApplicationEdge,
createJavaScriptApplicationGraph,
createJavaScriptApplicationNode,
javascriptApplicationGraphSchema,
mergeJavaScriptApplicationNodes,
parseJavaScriptApplicationGraph,
serializeJavaScriptApplicationGraph,
} from "./javascriptApplicationGraph.js";
import type { ApplicationNode } from "./javascriptApplicationGraphSchemas.js";
import {
APPLICATION_GRAPH_DIGESTS,
artifactEvidence,
@@ -33,51 +35,47 @@ it("merges observations by entity identity without changing source nodes", () =>
stability: "global-exact" as const,
strategy: "content-digest" as const,
};
expect(second.node_id).toBe(first.node_id);
expect(second.observations[0]?.observation_id).not.toBe(
first.observations[0]?.observation_id,
);
const sourceSnapshot = structuredClone([first, second]);
const merged = mergeJavaScriptApplicationNodes([
first,
{ ...second, identity: reversedIdentity },
first,
]);
expect(merged).toHaveLength(1);
const node = firstOf(merged, "merged node");
expect(node.node_id).toBe(first.node_id);
expect(node.observations.map(({ properties }) => properties)).toEqual(
expect.arrayContaining([{ selected: "first" }, { selected: "second" }]),
);
expect(node.observations).toHaveLength(2);
expect(first.observations).toHaveLength(1);
expect(second.observations).toHaveLength(1);
const graph = graphForNode(node);
expect(parseJavaScriptApplicationGraph(graph)).toEqual(graph);
expect(merged).toMatchObject([
{ node_id: first.node_id, identity: first.identity },
]);
expect(
merged[0]?.observations
.map(({ properties }) => properties)
.sort((left, right) =>
String(left.selected).localeCompare(String(right.selected)),
),
).toEqual([{ selected: "first" }, { selected: "second" }]);
expect([first, second]).toEqual(sourceSnapshot);
});
it.each(["kind", "identity"] as const)(
"rejects colliding entity IDs with a different %s before merging observations",
(field) => {
const node = contentNode(
artifactEvidence(APPLICATION_GRAPH_DIGESTS.asar, "main.js"),
);
const conflicting =
field === "kind"
? { ...node, kind: "javascript-asset" as const }
: {
...node,
identity: {
strategy: "content-digest" as const,
stability: "global-exact" as const,
sha256: "f".repeat(64),
},
};
expect(() => mergeJavaScriptApplicationNodes([node, conflicting])).toThrow(
it("rejects a colliding entity ID when the kind or identity disagrees", () => {
const node = contentNode(
artifactEvidence(APPLICATION_GRAPH_DIGESTS.asar, "main.js"),
);
const original = structuredClone(node);
const conflicts = [
{ ...node, kind: "javascript-asset" as const },
{
...node,
identity: {
strategy: "content-digest" as const,
stability: "global-exact" as const,
sha256: "f".repeat(64),
},
},
];
for (const conflict of conflicts)
expect(() => mergeJavaScriptApplicationNodes([node, conflict])).toThrow(
"Colliding JAG node identifiers disagree",
);
expect(node.observations).toHaveLength(1);
},
);
expect(node).toEqual(original);
});
it("preserves deep and wide observation properties in a large native-export graph", () => {
let nested: unknown = "leaf";
@@ -185,14 +183,6 @@ describe("JavaScript Application Graph: evidence authority", () => {
state: "observed",
});
expect(observedAs?.evidence.authority).toBe("passive-cdp-runtime");
expect(observedAs?.identifier_strategy).toEqual({
strategy: "semantic-content-sha256",
stability: "relationship-exact",
});
expect(runtime.observations[0]?.identifier_strategy).toEqual({
strategy: "semantic-content-sha256",
stability: "observation-exact",
});
expect(nativeExport.observations[0]?.evidence.authority).toBe(
"native-analysis-provider",
);
@@ -291,84 +281,53 @@ describe("JavaScript Application Graph: identity and evidence", () => {
expect(graphForNode(node).nodes).toEqual([node]);
});
it("scopes runtime identities to a capture and artifact paths to a version", () => {
const runtime = nodeByLabel(
buildSyntheticJavaScriptApplicationGraph(),
"preload runtime script",
);
const differentCapture = createJavaScriptApplicationNode({
kind: "runtime-script-instance",
identity: {
strategy: "runtime-instance",
stability: "capture-only",
capture_evidence_id: `ev_${"c".repeat(64)}`,
capture_sha256: "6".repeat(64),
runtime_key: "script-preload",
},
observations: [
{
label: "other capture",
properties: {},
evidence: {
...runtimeEvidence("script-preload"),
location: {
available: true,
value: {
kind: "runtime",
capture_sha256: "6".repeat(64),
target_key: "target-main",
frame_key: "frame-main",
script_key: "script-preload",
},
},
it("scopes the same artifact path to its version", () => {
const path = "dist/app.js";
const asset = (digest: string) =>
createJavaScriptApplicationNode({
kind: "javascript-asset",
identity: {
strategy: "canonical-path",
stability: "artifact-version",
artifact_sha256: digest,
path,
},
observations: [
{
label: null,
properties: {},
evidence: artifactEvidence(digest, path),
},
},
],
});
expect(differentCapture.node_id).not.toBe(runtime.node_id);
const firstArtifact = createJavaScriptApplicationNode({
kind: "javascript-asset",
identity: {
strategy: "canonical-path",
stability: "artifact-version",
artifact_sha256: APPLICATION_GRAPH_DIGESTS.asar,
path: "dist/app.js",
},
observations: [
{
label: null,
properties: {},
evidence: artifactEvidence(
APPLICATION_GRAPH_DIGESTS.asar,
"dist/app.js",
),
},
],
});
const secondArtifact = createJavaScriptApplicationNode({
kind: "javascript-asset",
identity: {
strategy: "canonical-path",
stability: "artifact-version",
artifact_sha256: "7".repeat(64),
path: "dist/app.js",
},
observations: [
{
label: null,
properties: {},
evidence: artifactEvidence("7".repeat(64), "dist/app.js"),
},
],
});
expect(firstArtifact.node_id).not.toBe(secondArtifact.node_id);
],
});
const earlier = asset(APPLICATION_GRAPH_DIGESTS.asar);
const later = asset("7".repeat(64));
expect(graphForNode(earlier).nodes[0]?.node_id).not.toBe(
graphForNode(later).nodes[0]?.node_id,
);
});
});
describe("JavaScript Application Graph: source maps and observations", () => {
it("requires source-map observations to retain the declaration and map location", () => {
const sourceModule = createJavaScriptApplicationNode({
it("requires every source-map observation to agree with the original source identity", () => {
const sourceDigest = "3".repeat(64);
const reference = sourceMapReference(
"webpack:///src/editor.ts",
null,
"dist/app.js.map",
);
const observed = artifactEvidence(
APPLICATION_GRAPH_DIGESTS.asar,
"dist/app.js.map",
"ast-static-analysis",
);
const mappedNode = (
digest: string | null,
observations: readonly Omit<
ApplicationNode["observations"][number],
"observation_id" | "identifier_strategy"
>[],
) =>
createJavaScriptApplicationNode({
kind: "source-module",
identity: {
strategy: "source-map-original",
@@ -376,177 +335,125 @@ describe("JavaScript Application Graph: source maps and observations", () => {
stability: "source-map-exact",
source_map_sha256: APPLICATION_GRAPH_DIGESTS.asar,
original_source: "webpack:///src/editor.ts",
source_sha256: null,
source_sha256: digest,
},
observations: [
{
label: "src/editor.ts",
source_map_reference: sourceMapReference(
"webpack:///src/editor.ts",
null,
"dist/app.js.map",
),
properties: { recovered_from: "source-map" },
evidence: artifactEvidence(
APPLICATION_GRAPH_DIGESTS.asar,
"dist/app.js.map",
"ast-static-analysis",
),
},
],
observations,
});
expect(graphForNode(sourceModule).nodes).toEqual([sourceModule]);
const sourceObservation = firstOf(
sourceModule.observations,
"source observation",
);
const {
source_map_reference,
observation_id,
identifier_strategy,
...withoutReference
} = sourceObservation;
void observation_id;
void identifier_strategy;
expect(() =>
graphForNode(
createJavaScriptApplicationNode({
kind: sourceModule.kind,
identity: sourceModule.identity,
observations: [withoutReference],
}),
),
).toThrow(/Source-map observation/u);
expect(() =>
graphForNode(
createJavaScriptApplicationNode({
kind: sourceModule.kind,
identity: sourceModule.identity,
observations: [
{
...withoutReference,
source_map_reference: {
...source_map_reference,
map_path: "different/map.js.map",
},
},
],
}),
),
).toThrow(/Source-map observation/u);
});
});
describe("JavaScript Application Graph: source-map digest consistency", () => {
it("rejects source-map observations that contradict a known original digest", () => {
const sourceMapNode = (
identityDigest: string | null,
observedDigest: unknown,
contentAvailable?: boolean,
) =>
createJavaScriptApplicationNode({
kind: "source-module",
identity: {
strategy: "source-map-original",
source_root: null,
stability: "source-map-exact",
source_map_sha256: APPLICATION_GRAPH_DIGESTS.asar,
original_source: "src/editor.ts",
source_sha256: identityDigest,
},
observations: [
{
label: null,
source_map_reference: sourceMapReference(
"src/editor.ts",
null,
"dist/app.js.map",
),
properties: {
...(contentAvailable === undefined
? {}
: { content_available: contentAvailable }),
...(observedDigest === undefined
? {}
: { content_sha256: observedDigest }),
},
evidence: artifactEvidence(
APPLICATION_GRAPH_DIGESTS.asar,
"dist/app.js.map",
"ast-static-analysis",
),
const known = {
label: "known source",
source_map_reference: reference,
properties: { content_sha256: sourceDigest, content_available: true },
evidence: observed,
};
const unknown = {
...known,
label: "unknown source",
properties: { content_sha256: null, content_available: false },
};
const knownGraph = graphForNode(mappedNode(sourceDigest, [known]));
const unknownGraph = graphForNode(mappedNode(null, [unknown]));
const rows = [
{
graph: knownGraph,
node: mappedNode(sourceDigest, [
known,
{ ...known, label: "missing declaration", source_map_reference: null },
{
...known,
label: "wrong map path",
source_map_reference: {
...reference,
map_path: "different/map.js.map",
},
],
});
expect(() =>
graphForNode(sourceMapNode("2".repeat(64), "3".repeat(64))),
).toThrow(/Source-map observation/u);
expect(() => graphForNode(sourceMapNode(null, "3".repeat(64)))).toThrow(
/Source-map observation/u,
);
expect(() => graphForNode(sourceMapNode(null, 7))).toThrow(
/Source-map observation/u,
);
expect(() =>
graphForNode(sourceMapNode("3".repeat(64), "3".repeat(64))),
).not.toThrow();
expect(() =>
graphForNode(sourceMapNode("3".repeat(64), "3".repeat(64), false)),
).toThrow(/Source-map observation/u);
expect(() =>
graphForNode(sourceMapNode("3".repeat(64), null, false)),
).toThrow(/Source-map observation/u);
expect(() =>
graphForNode(sourceMapNode("3".repeat(64), null, true)),
).toThrow(/Source-map observation/u);
expect(() =>
graphForNode(sourceMapNode("3".repeat(64), undefined)),
).toThrow(/Source-map observation/u);
expect(() => graphForNode(sourceMapNode(null, null, true))).toThrow(
/Source-map observation/u,
);
});
},
{
...known,
label: "different digest",
properties: { content_sha256: "2".repeat(64) },
},
{ ...known, label: "absent digest", properties: {} },
{
...known,
label: "discarded content",
properties: {
content_sha256: sourceDigest,
content_available: false,
},
},
]),
rejected: [
"absent digest",
"different digest",
"discarded content",
"missing declaration",
"wrong map path",
],
},
{
graph: unknownGraph,
node: mappedNode(null, [
unknown,
{
...unknown,
label: "unproven digest",
properties: { content_sha256: sourceDigest },
},
{
...unknown,
label: "non-digest content",
properties: { content_sha256: 7 },
},
{
...unknown,
label: "unproven content",
properties: { content_sha256: null, content_available: true },
},
]),
rejected: ["non-digest content", "unproven content", "unproven digest"],
},
];
for (const { graph, node, rejected } of rows) {
const parsed = javascriptApplicationGraphSchema.safeParse({
...graph,
nodes: [node],
});
const badLabels = parsed.error?.issues
.filter(({ path }) => path.at(-1) === "source_map_reference")
.map(({ path }) => node.observations[Number(path[3])]?.label)
.sort();
expect(badLabels).toEqual(rejected);
}
});
describe("JavaScript Application Graph: commitments and schemas", () => {
it("rejects unknown fields and stale commitments", () => {
const graph = buildSyntheticJavaScriptApplicationGraph();
expect(() =>
parseJavaScriptApplicationGraph({ ...graph, surprise: true }),
).toThrow();
it("rejects unknown fields and stale nested commitments at their owning fields", () => {
const graph = buildSyntheticJavaScriptApplicationGraph();
expect(
javascriptApplicationGraphSchema.safeParse({ ...graph, surprise: true })
.error?.issues,
).toMatchObject([
{ path: [], code: "unrecognized_keys", keys: ["surprise"] },
]);
const staleGraph = structuredClone(graph);
staleGraph.graph_id = `jag_${"f".repeat(64)}`;
expect(() => parseJavaScriptApplicationGraph(staleGraph)).toThrow(
/Graph identifier/u,
);
const staleNode = structuredClone(graph);
firstOf(staleNode.nodes, "node").node_id = `jag_node_${"f".repeat(64)}`;
expect(() => parseJavaScriptApplicationGraph(staleNode)).toThrow(
/Node identifier/u,
);
const staleObservation = structuredClone(graph);
firstOf(
firstOf(staleObservation.nodes, "node").observations,
"observation",
).observation_id = `jag_observation_${"f".repeat(64)}`;
expect(() => parseJavaScriptApplicationGraph(staleObservation)).toThrow(
/Observation identifier/u,
);
const staleEdge = structuredClone(graph);
firstOf(staleEdge.edges, "edge").edge_id = `jag_edge_${"f".repeat(64)}`;
expect(() => parseJavaScriptApplicationGraph(staleEdge)).toThrow(
/Edge identifier/u,
);
const { graph_id: _graphId, ...staleInput } = staleEdge;
expect(() => createJavaScriptApplicationGraph(staleInput)).toThrow(
/Edge identifier/u,
);
});
const staleNode = structuredClone(graph);
firstOf(staleNode.nodes, "node").node_id = `jag_node_${"f".repeat(64)}`;
const staleObservation = structuredClone(graph);
firstOf(
firstOf(staleObservation.nodes, "node").observations,
"observation",
).observation_id = `jag_observation_${"f".repeat(64)}`;
const staleEdge = structuredClone(graph);
firstOf(staleEdge.edges, "edge").edge_id = `jag_edge_${"f".repeat(64)}`;
for (const { input, path } of [
{ input: staleNode, path: ["nodes", 0, "node_id"] },
{
input: staleObservation,
path: ["nodes", 0, "observations", 0, "observation_id"],
},
{ input: staleEdge, path: ["edges", 0, "edge_id"] },
])
expect(
javascriptApplicationGraphSchema.safeParse(input).error?.issues,
).toContainEqual(expect.objectContaining({ path, code: "custom" }));
});
describe("JavaScript Application Graph: duplicate and orphan rejection", () => {
@@ -667,48 +574,67 @@ describe("JavaScript Application Graph: duplicate and orphan rejection", () => {
});
});
it("rejects runtime identities without an explicit capture Evidence identifier", () => {
expect(() =>
it("requires capture provenance for runtime script identities", () => {
const captureEvidenceId = `ev_${"c".repeat(64)}`;
const identity = {
strategy: "runtime-instance",
stability: "capture-only",
capture_sha256: APPLICATION_GRAPH_DIGESTS.capture,
runtime_key: "script-preload",
};
const node = (
candidate: unknown,
evidence = runtimeEvidence("script-preload"),
) =>
createJavaScriptApplicationNode({
kind: "runtime-script-instance",
identity: {
strategy: "runtime-instance",
stability: "capture-only",
capture_sha256: APPLICATION_GRAPH_DIGESTS.capture,
runtime_key: "script-preload",
},
observations: [
{
label: null,
properties: {},
evidence: runtimeEvidence("script-preload"),
},
],
}),
).toThrow(/capture_evidence_id/u);
});
identity: candidate,
observations: [{ label: "preload", properties: {}, evidence }],
});
expect(() => node(identity)).toThrow(/capture_evidence_id/u);
const matching = { ...identity, capture_evidence_id: captureEvidenceId };
const runtime = node(matching);
expect(graphForNode(runtime).nodes).toEqual([runtime]);
it("requires runtime identities to retain their capture Evidence provenance", () => {
const runtimeWithUnrelatedEvidence = createJavaScriptApplicationNode({
kind: "runtime-script-instance",
identity: {
strategy: "runtime-instance",
stability: "capture-only",
capture_evidence_id: `ev_${"d".repeat(64)}`,
capture_sha256: APPLICATION_GRAPH_DIGESTS.capture,
runtime_key: "script-preload",
},
observations: [
{
label: null,
properties: {},
evidence: runtimeEvidence("script-preload"),
},
],
});
expect(() => graphForNode(runtimeWithUnrelatedEvidence)).toThrow(
const otherEvidenceId = `ev_${"d".repeat(64)}`;
const foreign = { ...identity, capture_evidence_id: otherEvidenceId };
expect(() => graphForNode(node(foreign))).toThrow(
/identity is not supported/u,
);
expect(() =>
graphForNode(
node(
matching,
artifactEvidence(
APPLICATION_GRAPH_DIGESTS.asar,
"dist/preload.js",
"ast-static-analysis",
),
),
),
).toThrow(/identity is not supported/u);
const otherEvidence = runtimeEvidence("script-preload");
otherEvidence.evidence_ids = [otherEvidenceId];
const otherCapture = node(foreign, otherEvidence);
expect(graphForNode(otherCapture).nodes[0]?.node_id).not.toBe(
runtime.node_id,
);
const otherDigest = "6".repeat(64);
const otherLocation = runtimeEvidence("script-preload");
if (
!otherLocation.location.available ||
otherLocation.location.value.kind !== "runtime"
)
throw new Error("Missing fixture runtime location");
otherLocation.location.value.capture_sha256 = otherDigest;
const relocatedCapture = node(
{ ...matching, capture_sha256: otherDigest },
otherLocation,
);
expect(graphForNode(relocatedCapture).nodes[0]?.node_id).not.toBe(
runtime.node_id,
);
});
describe("JavaScript Application Graph: identity strategy requirements", () => {
@@ -736,31 +662,6 @@ describe("JavaScript Application Graph: identity strategy requirements", () => {
/identity is not supported/u,
);
const runtimeWithStaticEvidence = createJavaScriptApplicationNode({
kind: "runtime-script-instance",
identity: {
strategy: "runtime-instance",
stability: "capture-only",
capture_evidence_id: `ev_${"c".repeat(64)}`,
capture_sha256: APPLICATION_GRAPH_DIGESTS.capture,
runtime_key: "script-preload",
},
observations: [
{
label: null,
properties: {},
evidence: artifactEvidence(
APPLICATION_GRAPH_DIGESTS.asar,
"dist/preload.js",
"ast-static-analysis",
),
},
],
});
expect(() => graphForNode(runtimeWithStaticEvidence)).toThrow(
/identity is not supported/u,
);
const mismatchedDigest = contentNode(
artifactEvidence("7".repeat(64), "dist/module.js"),
);
@@ -787,20 +688,49 @@ describe("JavaScript Application Graph: identity strategy requirements", () => {
);
});
it.each(["ast-static-analysis", "managed-static-analysis"] as const)(
"prevents %s from claiming runtime locations",
(authority) => {
const evidence = artifactEvidence(
APPLICATION_GRAPH_DIGESTS.asar,
"dist/module.js",
authority,
);
evidence.location = runtimeEvidence("script-module").location;
expect(() => graphForNode(contentNode(evidence))).toThrow(
/cannot claim a runtime location/u,
);
},
);
it("requires static and native locations to agree with their observation authority", () => {
const path = "dist/module.js";
const base = contentNode(
artifactEvidence(APPLICATION_GRAPH_DIGESTS.asar, path),
);
const graph = graphForNode(base);
const badAuthority = [
"ast-static-analysis",
"managed-static-analysis",
"native-analysis-provider",
] as const;
const mixed = firstOf(
mergeJavaScriptApplicationNodes([
base,
...badAuthority.map((authority) => {
const evidence = artifactEvidence(
APPLICATION_GRAPH_DIGESTS.asar,
path,
authority,
);
evidence.location = runtimeEvidence("script-module").location;
return contentNode(evidence);
}),
]),
"mixed authority node",
);
const rejected = javascriptApplicationGraphSchema
.safeParse({
...graph,
nodes: [mixed],
})
.error?.issues.filter(
({ message, path }) =>
path.at(-1) === "location" &&
message ===
"Static and native authorities cannot claim a runtime location",
)
.map(
({ path }) => mixed.observations[Number(path[3])]?.evidence.authority,
)
.sort();
expect(rejected).toEqual(badAuthority);
});
it("enforces epistemic truthfulness and content-addressed artifacts", () => {
const inferredAsObserved = inferredArtifactEvidence(
@@ -7,8 +7,6 @@ import {
createJavaScriptApplicationEdge,
createJavaScriptApplicationGraph,
createJavaScriptApplicationNode,
isValidatedImmutableJavaScriptApplicationGraph,
parseJavaScriptApplicationGraph,
type JavaScriptApplicationGraph,
} from "./javascriptApplicationGraph.js";
import {
@@ -99,8 +97,8 @@ const compare = () =>
rightNativeEvidence: [],
});
const unrelatedGraph = (artifactSha: string): JavaScriptApplicationGraph => {
const node = createJavaScriptApplicationNode({
const unrelatedNode = (artifactSha: string) =>
createJavaScriptApplicationNode({
kind: "javascript-chunk",
identity: {
strategy: "canonical-path",
@@ -116,15 +114,6 @@ const unrelatedGraph = (artifactSha: string): JavaScriptApplicationGraph => {
},
],
});
return createJavaScriptApplicationGraph({
schema: "JavaScriptApplicationGraph",
root_node_ids: [node.node_id],
nodes: [node],
edges: [],
coverage: completeCoverage,
limitations: [],
});
};
const nativeEvidence = (sha256: string | undefined, ordinal: number) =>
createEvidence(
@@ -260,108 +249,93 @@ it.each(occurrenceDifferences)(
},
);
describe("application version comparison Evidence links", () => {
it("links every exact digest observation only to its paired or unmatched item", () => {
const left = buildGraph(LEFT_SHA, 1);
const right = buildGraph(RIGHT_SHA, 2);
const leftEvidenceId = `ev_${"1".repeat(64)}`;
const rightEvidenceId = `ev_${"2".repeat(64)}`;
const leftBDigest = `${"0".repeat(63)}1`;
const leftNative = [
nativeEvidence(leftBDigest, 1),
nativeEvidence(leftBDigest, 2),
nativeEvidence("9".repeat(64), 3),
];
const rightNative = [
nativeEvidence("0".repeat(64), 4),
it("attributes native Evidence to exact observations on the owning side", () => {
const left = buildGraph(LEFT_SHA, 1);
const fullRight = buildGraph(RIGHT_SHA, 2);
const byLabel = (graph: JavaScriptApplicationGraph, label: string) => {
const node = graph.nodes.find(({ observations }) =>
observations.some((value) => value.label === label),
);
if (node === undefined) throw new Error(`Missing fixture node ${label}`);
return node;
};
const leftA = byLabel(left, "a.js");
const leftB = byLabel(left, "b.js");
const rightA = byLabel(fullRight, "a.js");
const rightB = byLabel(fullRight, "b.js");
const unrelated = unrelatedNode(RIGHT_SHA);
const { graph_id: _graphId, ...rightInput } = fullRight;
const right = createJavaScriptApplicationGraph({
...rightInput,
nodes: [
...fullRight.nodes.filter(({ node_id }) => node_id !== rightB.node_id),
unrelated,
],
edges: fullRight.edges.filter(
({ source_node_id, target_node_id }) =>
source_node_id !== rightB.node_id && target_node_id !== rightB.node_id,
),
});
const leftEvidenceId = `ev_${"1".repeat(64)}`;
const rightEvidenceId = `ev_${"2".repeat(64)}`;
const parents = [leftEvidenceId, rightEvidenceId];
const bDigest = `${"0".repeat(63)}1`;
const leftNativeA = nativeEvidence("0".repeat(64), 1);
const leftNativeB = nativeEvidence(bDigest, 2);
const leftNativeB2 = nativeEvidence(bDigest, 3);
const rightNativeA = nativeEvidence("0".repeat(64), 4);
const result = compareJavaScriptApplicationVersions({
left: {
evidenceId: leftEvidenceId,
rootArtifactSha256: LEFT_SHA,
graph: left,
},
right: {
evidenceId: rightEvidenceId,
rootArtifactSha256: RIGHT_SHA,
graph: right,
},
leftNativeEvidence: [leftNativeA, leftNativeB, leftNativeB2],
rightNativeEvidence: [
rightNativeA,
nativeEvidence(bDigest, 5),
nativeEvidence(undefined, 6),
];
const unrelatedRight = unrelatedGraph(RIGHT_SHA);
const unmatched = compareJavaScriptApplicationVersions({
left: {
evidenceId: leftEvidenceId,
rootArtifactSha256: LEFT_SHA,
graph: left,
},
right: {
evidenceId: rightEvidenceId,
rootArtifactSha256: RIGHT_SHA,
graph: unrelatedRight,
},
leftNativeEvidence: leftNative,
rightNativeEvidence: rightNative,
});
const leftB = left.nodes.find(({ observations }) =>
observations.some(({ label }) => label === "b.js"),
);
if (leftB === undefined) throw new Error("Missing left b.js node");
const unmatchedB = unmatched.items.find(
({ left_node_id: id }) => id === leftB.node_id,
);
expect(unmatchedB?.evidence_links).toEqual(
[
leftEvidenceId,
rightEvidenceId,
leftNative[0]!.evidence_id,
leftNative[1]!.evidence_id,
].sort(),
);
const unrelatedItem = unmatched.items.find(
({ right_node_id: id }) => id === unrelatedRight.nodes[0]?.node_id,
);
expect(unrelatedItem?.evidence_links).toEqual(
[leftEvidenceId, rightEvidenceId].sort(),
);
const paired = compareJavaScriptApplicationVersions({
left: {
evidenceId: leftEvidenceId,
rootArtifactSha256: LEFT_SHA,
graph: left,
},
right: {
evidenceId: rightEvidenceId,
rootArtifactSha256: RIGHT_SHA,
graph: right,
},
leftNativeEvidence: [nativeEvidence("0".repeat(64), 5)],
rightNativeEvidence: rightNative,
});
const leftA = left.nodes.find(({ observations }) =>
observations.some(({ label }) => label === "a.js"),
);
if (leftA === undefined) throw new Error("Missing left a.js node");
const pairedA = paired.items.find(
({ left_node_id: id }) => id === leftA.node_id,
);
expect(pairedA?.match.status).toBe("matched");
expect(pairedA?.evidence_links).toEqual(
[
leftEvidenceId,
rightEvidenceId,
nativeEvidence("0".repeat(64), 5).evidence_id,
rightNative[0]!.evidence_id,
].sort(),
);
],
});
expect(
result.items.find(({ left_node_id }) => left_node_id === leftA.node_id),
).toMatchObject({
right_node_id: rightA.node_id,
match: { status: "matched" },
evidence_links: [
...parents,
leftNativeA.evidence_id,
rightNativeA.evidence_id,
].sort(),
});
expect(
result.items.find(({ left_node_id }) => left_node_id === leftB.node_id),
).toMatchObject({
right_node_id: null,
status: "removed",
evidence_links: [
...parents,
leftNativeB.evidence_id,
leftNativeB2.evidence_id,
].sort(),
});
expect(
result.items.find(
({ right_node_id }) => right_node_id === unrelated.node_id,
),
).toMatchObject({
left_node_id: null,
status: "added",
evidence_links: parents.sort(),
});
});
describe("application version comparison graph ownership", () => {
it("returns a sealed change graph that passes complete validation", () => {
const result = compare();
expect(
result.graph.edges.some(({ relation }) => relation === "changed_from"),
).toBe(true);
expect(isValidatedImmutableJavaScriptApplicationGraph(result.graph)).toBe(
true,
);
expect(Object.isFrozen(result.graph.edges)).toBe(true);
expect(parseJavaScriptApplicationGraph(result.graph)).toEqual(result.graph);
expect(applicationVersionComparisonResultSchema.parse(result)).toEqual(
result,
);
});
it("retains deduplicated complete input limits on the change graph and inferred edge", () => {
const leftLimits = [
{ name: "modules", value: 100, unit: "items" as const },
@@ -414,30 +388,46 @@ describe("application version comparison graph ownership", () => {
});
});
it("does not reuse a change graph without an owned proof", () => {
it("reuses only the owned change graph and validates its enclosing result", () => {
const result = compare();
const copy = structuredClone(result.graph);
expect(isValidatedImmutableJavaScriptApplicationGraph(copy)).toBe(false);
expect(() =>
ownedApplicationVersionComparisonResultSchema.parse({
...result,
graph: copy,
}),
).toThrow();
expect(
applicationVersionComparisonResultSchema.parse({ ...result, graph: copy })
.graph,
).toEqual(result.graph);
});
ownedApplicationVersionComparisonResultSchema.parse(result).graph,
).toBe(result.graph);
it("keeps coverage validation for owned results", () => {
const result = compare();
expect(() =>
ownedApplicationVersionComparisonResultSchema.parse({
const copied = { ...result, graph: structuredClone(result.graph) };
expect(
ownedApplicationVersionComparisonResultSchema.safeParse(copied).error
?.issues,
).toMatchObject([{ path: ["graph"] }]);
expect(applicationVersionComparisonResultSchema.parse(copied)).toEqual(
result,
);
for (const status of ["partial", "unknown"] as const) {
const checked = ownedApplicationVersionComparisonResultSchema.safeParse({
...result,
coverage: { ...result.coverage, status: "partial" },
}),
).toThrow("Comparison coverage must match source graph completeness");
coverage: { ...result.coverage, status },
});
const messages = checked.error?.issues.map(({ path, message }) => ({
path,
message,
}));
expect(messages).toEqual([
{
path: ["coverage", "status"],
message: "Comparison coverage must match source graph completeness",
},
...(status === "unknown"
? [
{
path: ["coverage", "status"],
message:
"Comparison coverage is unknown exactly when a source graph's coverage is unknown or unavailable",
},
]
: []),
]);
}
});
});
@@ -485,45 +475,54 @@ describe("version comparison coverage", () => {
limits: [{ name: "modules", value: 3, unit: "items" }],
};
it.each(["unknown", "unavailable"] as const)(
"reports unknown, not a known gap, when a source graph is %s",
(status) => {
const result = compareWith(completeCoverage, unknown(status));
expect(result.coverage).toMatchObject({
right_graph_status: status,
status: "unknown",
});
// The change graph and each changed_from edge make the same claim.
expect(result.graph.coverage).toMatchObject({
it.each([
{
name: "unknown source",
left: unknown("unknown"),
right: completeCoverage,
status: "unknown",
graphCoverage: {
status: "unknown",
truncated: false,
omitted_count: null,
},
},
{
name: "unavailable source with truncation",
left: truncated,
right: unknown("unavailable"),
status: "unknown",
graphCoverage: {
status: "unknown",
truncated: false,
omitted_count: null,
},
},
{
name: "reported truncation",
left: truncated,
right: completeCoverage,
status: "truncated",
graphCoverage: { status: "partial", truncated: true, omitted_count: 3 },
},
])(
"publishes supported coverage for $name",
({ left, right, status, graphCoverage }) => {
const result = compareWith(left, right);
expect(result.coverage).toEqual({
status,
left_graph_status: left.status,
right_graph_status: right.status,
left_graph_omitted_count: left.omitted_count,
right_graph_omitted_count: right.omitted_count,
});
expect(result.graph.coverage).toMatchObject(graphCoverage);
const changed = result.graph.edges.filter(
({ relation }) => relation === "changed_from",
);
expect(changed.length).toBeGreaterThan(0);
for (const edge of changed)
expect(edge.evidence.coverage.status).toBe("unknown");
// Unknown wins over a known truncation on the other side.
expect(compareWith(truncated, unknown(status)).coverage.status).toBe(
"unknown",
);
expect(edge.evidence.coverage).toMatchObject(graphCoverage);
},
);
it("keeps a known truncation when both graphs report their coverage", () => {
expect(compareWith(truncated, completeCoverage).coverage.status).toBe(
"truncated",
);
});
it("refuses an unknown status that the source graphs do not support", () => {
const result = compare();
expect(() =>
ownedApplicationVersionComparisonResultSchema.parse({
...result,
coverage: { ...result.coverage, status: "unknown" },
}),
).toThrow(/unknown exactly when/u);
});
});
@@ -70,28 +70,53 @@ const compare = (
rightNativeEvidence: [],
});
describe("application version matching", () => {
it.each([
["babel-ast-v1", "babel-ast-v1"],
["babel-ast-v2", "babel-ast-v2"],
["babel-ast-v3", "babel-ast-v3"],
["babel-ast-v1", "babel-ast-v2"],
["babel-ast-v1", "babel-ast-v3"],
["babel-ast-v2", "babel-ast-v3"],
])(
"compares %s with %s without mixing fingerprint algorithms",
(leftAlgorithm, rightAlgorithm) => {
const left = moduleNode("before", "1", "a", leftAlgorithm);
const right = moduleNode("after", "2", "a", rightAlgorithm);
const result = compare(graph([left]), graph([right]));
const sameAlgorithm = leftAlgorithm === rightAlgorithm;
expect(result.matching.structural_fingerprint).toBe(
sameAlgorithm ? 1 : 0,
);
expect(result.matching.unmatched).toBe(sameAlgorithm ? 0 : 2);
},
);
it("matches equal digests only within the same archived fingerprint algorithm", () => {
const left = [
moduleNode("left-v1", "1", "a", "babel-ast-v1"),
moduleNode("left-v2", "2", "a", "babel-ast-v2"),
moduleNode("left-v3", "3", "a", "babel-ast-v3"),
moduleNode("left-incompatible", "4", "b", "babel-ast-v1"),
] as const;
const right = [
moduleNode("right-v3", "5", "a", "babel-ast-v3"),
moduleNode("right-v2", "6", "a", "babel-ast-v2"),
moduleNode("right-v1", "7", "a", "babel-ast-v1"),
moduleNode("right-incompatible", "8", "b", "babel-ast-v3"),
] as const;
const result = compare(graph([...left]), graph([...right]));
expect(result.items).toHaveLength(5);
for (const [before, after] of [
[left[0], right[2]],
[left[1], right[1]],
[left[2], right[0]],
] as const) {
expect(
result.items.find(({ left_node_id }) => left_node_id === before.node_id),
).toMatchObject({
right_node_id: after.node_id,
status: "changed",
match: { status: "matched", basis: "structural-fingerprint" },
});
}
expect(
result.items.find(({ left_node_id }) => left_node_id === left[3].node_id),
).toMatchObject({
right_node_id: null,
status: "removed",
match: { status: "unmatched" },
});
expect(
result.items.find(
({ right_node_id }) => right_node_id === right[3].node_id,
),
).toMatchObject({
left_node_id: null,
status: "added",
match: { status: "unmatched" },
});
});
describe("application version matching", () => {
it("does not revisit a source group that becomes unique after identity matching", () => {
const shared = moduleNode("shared", "1");
const leftOnly = moduleNode("left", "1");
@@ -12,10 +12,9 @@ import { compareJavaScriptApplicationVersions } from "./javascriptApplicationVer
const graph = (
sha: string,
peers: "ambiguous" | "unique" | "unmatched",
peers: "ambiguous" | "unmatched",
options: {
relation?: "imports" | "invokes";
target?: "peer-one" | "peer-two";
direction?: "in" | "out";
content?: string;
partial?: true;
@@ -39,9 +38,7 @@ const graph = (
? (options.content ?? "d".repeat(64))
: peers === "ambiguous"
? "c".repeat(64)
: peers === "unique"
? (key === "peer-one" ? "e" : "f").repeat(64)
: (key === "peer-one" ? "1" : "2").repeat(64),
: (key === "peer-one" ? "1" : "2").repeat(64),
...(key === "main"
? {
structural_fingerprint_sha256: "9".repeat(64),
@@ -52,8 +49,7 @@ const graph = (
evidence,
),
);
const main = nodes[0],
target = nodes[options.target === "peer-two" ? 2 : 1];
const [main, target] = nodes;
if (main === undefined || target === undefined)
throw new Error("Missing fixture nodes");
return {
@@ -147,15 +143,6 @@ it.each(["ambiguous", "unmatched"] as const)(
},
);
it("keeps equal relationships to uniquely paired peers unchanged", () => {
const { item } = compare(
graph("a".repeat(64), "unique"),
graph("b".repeat(64), "unique"),
);
expect(item).toMatchObject({ status: "unchanged", dimensions: [] });
expect(item.limitations).toEqual([]);
});
it.each([{ relation: "invokes" as const }, { direction: "in" as const }])(
"retains positive relation/direction differences beside unknown peer identity %j",
(options) => {
@@ -173,17 +160,6 @@ it.each([{ relation: "invokes" as const }, { direction: "in" as const }])(
},
);
it("reports a resolved target change", () => {
const { item } = compare(
graph("a".repeat(64), "unique"),
graph("b".repeat(64), "unique", { target: "peer-two" }),
);
expect(item).toMatchObject({
status: "changed",
dimensions: ["relationships"],
});
});
it("preserves definite content change alongside unresolved relationships", () => {
const { item } = compare(
graph("a".repeat(64), "ambiguous"),
@@ -1,4 +1,4 @@
import { describe, expect, it } from "vitest";
import { expect, it } from "vitest";
import {
createJavaScriptApplicationEdge,
@@ -25,10 +25,8 @@ const sourceDigest = (name: string): string =>
const buildGraph = (
artifactSha: string,
edges: readonly EdgeSpec[],
order: "forward" | "reverse" = "forward",
): JavaScriptApplicationGraph => {
const names = order === "forward" ? [...NAMES] : [...NAMES].reverse();
const nodes = names.map((name) =>
const nodes = NAMES.map((name) =>
createJavaScriptApplicationNode({
kind: "javascript-module",
identity: {
@@ -55,12 +53,11 @@ const buildGraph = (
if (node === undefined) throw new Error(`Missing fixture node ${name}`);
return node.node_id;
};
const ordered = order === "forward" ? [...edges] : [...edges].reverse();
return createJavaScriptApplicationGraph({
schema: "JavaScriptApplicationGraph",
root_node_ids: [idOf("a")],
nodes,
edges: ordered.map(([source, target, relation]) =>
edges: edges.map(([source, target, relation]) =>
createJavaScriptApplicationEdge({
source_node_id: idOf(source),
target_node_id: idOf(target),
@@ -74,11 +71,11 @@ const buildGraph = (
});
};
const relationshipChanges = (
const compare = (
left: JavaScriptApplicationGraph,
right: JavaScriptApplicationGraph,
): string[] => {
const result = compareJavaScriptApplicationVersions({
) => {
return compareJavaScriptApplicationVersions({
left: {
evidenceId: `ev_${"1".repeat(64)}`,
rootArtifactSha256: LEFT_SHA,
@@ -92,17 +89,6 @@ const relationshipChanges = (
leftNativeEvidence: [],
rightNativeEvidence: [],
});
expect(result.summary.added + result.summary.removed).toBe(0);
return result.items
.filter(({ dimensions }) => dimensions.includes("relationships"))
.map(({ left_node_id: id }) => {
const node = left.nodes.find(({ node_id: nodeId }) => nodeId === id);
const label = node?.observations[0]?.label;
if (label === undefined || label === null)
throw new Error("Changed item has no node");
return label;
})
.sort();
};
const BASE_EDGES: readonly EdgeSpec[] = [
@@ -112,64 +98,93 @@ const BASE_EDGES: readonly EdgeSpec[] = [
["c", "b", "imports"],
];
describe("application version relationship comparison", () => {
it("reports no relationship change for identical topology in any node or edge order", () => {
expect(
relationshipChanges(
buildGraph(LEFT_SHA, BASE_EDGES),
buildGraph(RIGHT_SHA, BASE_EDGES, "reverse"),
),
).toEqual([]);
});
it("keeps paired relationships unchanged regardless of observation order", () => {
const left = buildGraph(LEFT_SHA, BASE_EDGES);
const right = buildGraph(RIGHT_SHA, BASE_EDGES);
const result = compare(left, right);
expect(result.items).toHaveLength(NAMES.length);
expect(result.items).toMatchObject(
Array.from(NAMES, () => ({
status: "unchanged",
dimensions: [],
limitations: [],
match: { basis: "exact-module-source-digest" },
})),
);
expect(
compare(left, {
...right,
nodes: [...right.nodes].reverse(),
edges: [...right.edges].reverse(),
}),
).toEqual(result);
});
it("flags both endpoints when an edge relation changes", () => {
const changed: readonly EdgeSpec[] = [
it.each<{
name: string;
before: readonly EdgeSpec[];
after: readonly EdgeSpec[];
changed: readonly ModuleName[];
}>([
{
name: "relation kind",
before: BASE_EDGES,
after: [
["a", "b", "imports"],
["b", "c", "contains"],
["a", "c", "contains"],
["c", "b", "imports"],
];
expect(
relationshipChanges(
buildGraph(LEFT_SHA, BASE_EDGES),
buildGraph(RIGHT_SHA, changed),
),
).toEqual(["b.js", "c.js"]);
});
it("flags a node whose only change is an incoming edge", () => {
const left: readonly EdgeSpec[] = [["a", "b", "imports"]];
const right: readonly EdgeSpec[] = [
],
changed: ["b", "c"],
},
{
name: "new inbound edge",
before: [["a", "b", "imports"]],
after: [
["a", "b", "imports"],
["c", "b", "imports"],
];
expect(
relationshipChanges(
buildGraph(LEFT_SHA, left),
buildGraph(RIGHT_SHA, right),
),
).toEqual(["b.js", "c.js"]);
});
it("flags a node when an edge is re-pointed at a different matched neighbour", () => {
const left: readonly EdgeSpec[] = [["a", "b", "imports"]];
const right: readonly EdgeSpec[] = [["a", "c", "imports"]];
expect(
relationshipChanges(
buildGraph(LEFT_SHA, left),
buildGraph(RIGHT_SHA, right),
),
).toEqual(["a.js", "b.js", "c.js"]);
});
it("distinguishes edge direction between the same pair", () => {
const left: readonly EdgeSpec[] = [["a", "b", "imports"]];
const right: readonly EdgeSpec[] = [["b", "a", "imports"]];
expect(
relationshipChanges(
buildGraph(LEFT_SHA, left),
buildGraph(RIGHT_SHA, right),
),
).toEqual(["a.js", "b.js"]);
});
});
],
changed: ["b", "c"],
},
{
name: "new matched target",
before: [["a", "b", "imports"]],
after: [["a", "c", "imports"]],
changed: ["a", "b", "c"],
},
{
name: "reversed edge",
before: [["a", "b", "imports"]],
after: [["b", "a", "imports"]],
changed: ["a", "b"],
},
])(
"reports exact endpoint changes for a $name",
({ before, after, changed }) => {
const left = buildGraph(LEFT_SHA, before);
const right = buildGraph(RIGHT_SHA, after);
const result = compare(left, right);
expect(result.items).toHaveLength(NAMES.length);
for (const name of NAMES) {
const path = `${name}.js`;
const oldNode = left.nodes.find(
({ observations }) => observations[0]?.label === path,
);
const newNode = right.nodes.find(
({ observations }) => observations[0]?.label === path,
);
const affected = changed.includes(name);
expect(
result.items.find(
({ left_node_id }) => left_node_id === oldNode?.node_id,
),
path,
).toMatchObject({
right_node_id: newNode?.node_id,
status: affected ? "changed" : "unchanged",
dimensions: affected ? ["relationships"] : [],
match: { basis: "exact-module-source-digest" },
});
}
},
);
@@ -135,40 +135,35 @@ const partialCoverage: JavaScriptApplicationGraph["coverage"] = {
omitted_count: null,
};
it("does not report a candidate-only IPC edge as a definite relationship change", () => {
const result = compare(
graph("a".repeat(64), 10, partialCoverage, { candidate: true }),
graph("b".repeat(64), 50, partialCoverage, {
noEdge: true,
permission: "changed",
}),
);
const channel = result.items.find((item) => item.node_kind === "ipc-channel");
expect(channel?.status).toBe("changed");
expect(channel?.dimensions).toContain("properties");
expect(channel?.dimensions).not.toContain("relationships");
expect(channel?.limitations.length).toBeGreaterThan(0);
});
it.each([false, true])(
"keeps a candidate and a definite equivalent uncertain when reversed: %s",
(reverse) => {
const candidate = graph("a".repeat(64), 10, partialCoverage, {
candidate: true,
});
const definite = graph("b".repeat(64), 50, partialCoverage, {
permission: "changed",
});
const result = reverse
? compare(definite, candidate)
: compare(candidate, definite);
it("keeps candidate edges uncertain against missing and definite counterparts", () => {
const candidate = graph("a".repeat(64), 10, partialCoverage, {
candidate: true,
});
const absent = graph("b".repeat(64), 50, partialCoverage, {
noEdge: true,
permission: "changed",
});
const definite = graph("b".repeat(64), 50, partialCoverage, {
permission: "changed",
});
for (const [left, right] of [
[candidate, absent],
[candidate, definite],
[definite, candidate],
] as const) {
const result = compare(left, right);
const channel = result.items.find(
(item) => item.node_kind === "ipc-channel",
({ node_kind }) => node_kind === "ipc-channel",
);
expect(channel?.status).toBe("changed");
expect(channel?.dimensions).not.toContain("relationships");
},
);
expect(channel).toMatchObject({
status: "changed",
dimensions: ["location", "properties"],
limitations: expect.arrayContaining([
"Incomplete source coverage leaves some candidate relationships unconfirmed.",
]),
});
}
});
it("retains an independent definite relationship change beside candidate edges", () => {
const result = compare(
@@ -180,8 +175,10 @@ it("retains an independent definite relationship change beside candidate edges",
}),
);
const channel = result.items.find((item) => item.node_kind === "ipc-channel");
expect(channel?.status).toBe("changed");
expect(channel?.dimensions).toContain("relationships");
expect(channel).toMatchObject({
status: "changed",
dimensions: ["location", "properties", "relationships"],
});
});
it("keeps relocated exact modules and inferred channels unchanged while retaining both coordinates", () => {
@@ -257,34 +254,31 @@ it("still classifies complete relationship changes beside relocation as changed"
expect(item.dimensions).toEqual(["location", "relationships"]);
});
it("retains definite content changes under partial coverage alongside relocation", () => {
it("retains independent content and property changes beside relocation under partial coverage", () => {
const result = compare(
graph("a".repeat(64), 10, completeCoverage),
graph("b".repeat(64), 50, partialCoverage, { content: "e".repeat(64) }),
graph("b".repeat(64), 50, partialCoverage, {
content: "e".repeat(64),
permission: "changed",
}),
);
expect(result.summary).toEqual({
unchanged: 0,
added: 0,
removed: 0,
changed: 2,
unknown: 0,
});
expect(
result.items.find((item) => item.node_kind === "javascript-module"),
result.items.find(({ node_kind }) => node_kind === "javascript-module"),
).toMatchObject({
status: "changed",
dimensions: ["content", "location", "properties"],
});
expect(
result.items.find((item) => item.node_kind === "ipc-channel")?.status,
).toBe("unknown");
});
it("retains definite property changes beside relocation", () => {
const result = compare(
graph("a".repeat(64), 10, completeCoverage),
graph("b".repeat(64), 50, partialCoverage, { permission: "changed" }),
);
expect(
result.items.find((item) => item.node_kind === "ipc-channel"),
result.items.find(({ node_kind }) => node_kind === "ipc-channel"),
).toMatchObject({
status: "changed",
dimensions: ["location", "properties"],
});
expect(
result.items.find((item) => item.node_kind === "javascript-module")?.status,
).toBe("unknown");
});
@@ -109,37 +109,6 @@ const compare = (
rightNativeEvidence: [],
});
it("keeps unmatched unavailable scopes unknown in either direction", () => {
const leftRoot = node("d".repeat(64), "main.js");
const rightRoot = node("d".repeat(64), "main.js");
const leftScope = unavailableScope(LEFT_SHA);
const rightScope = unavailableScope(RIGHT_SHA);
const forward = compare([leftRoot], [rightRoot, rightScope]);
const reverse = compare([leftRoot, leftScope], [rightRoot]);
expect(
forward.items.find(
({ right_node_id }) => right_node_id === rightScope.node_id,
),
).toMatchObject({
status: "unknown",
dimensions: ["availability"],
limitations: [LIMITATION],
evidence_links: [evidenceId("1"), evidenceId("2")],
});
expect(
reverse.items.find(
({ left_node_id }) => left_node_id === leftScope.node_id,
),
).toMatchObject({
status: "unknown",
dimensions: ["availability"],
limitations: [LIMITATION],
});
expect(forward.summary).toMatchObject({ added: 0, removed: 0, unknown: 1 });
expect(reverse.summary).toMatchObject({ added: 0, removed: 0, unknown: 1 });
});
it("keeps matched unavailable scopes unknown with their source limitation", () => {
const leftRoot = node("d".repeat(64), "main.js");
const rightRoot = node("d".repeat(64), "main.js");
@@ -162,48 +131,52 @@ it("retains unknown scope facts and reports genuine entity changes", () => {
const leftRoot = node("d".repeat(64), "main.js");
const rightRoot = node("d".repeat(64), "main.js");
const unknown = unavailableScope(RIGHT_SHA, "unknown");
const added = node("e".repeat(64), "new.js");
const unavailable = unavailableScope(LEFT_SHA);
const removed = node("f".repeat(64), "removed.js");
const mixedEvidenceAddition = observedAssetWithUnavailableFact();
const unknownResult = compare([leftRoot], [rightRoot, unknown]);
const addedResult = compare([leftRoot], [rightRoot, added]);
const removedResult = compare([leftRoot, removed], [rightRoot]);
const mixedResult = compare([leftRoot], [rightRoot, mixedEvidenceAddition]);
const added = observedAssetWithUnavailableFact();
const result = compare(
[leftRoot, removed, unavailable],
[rightRoot, added, unknown],
);
expect(
unknownResult.items.find(
({ right_node_id }) => right_node_id === unknown.node_id,
),
).toMatchObject({ status: "unknown", limitations: [LIMITATION] });
expect(unknownResult.summary).toMatchObject({ added: 0, unknown: 1 });
expect(
addedResult.items.find(
({ right_node_id }) => right_node_id === added.node_id,
),
).toMatchObject({ status: "added", dimensions: ["availability"] });
expect(addedResult.summary.added).toBe(1);
expect(
mixedResult.items.find(
({ right_node_id }) => right_node_id === mixedEvidenceAddition.node_id,
),
).toMatchObject({ status: "added", limitations: [LIMITATION] });
expect(mixedResult.summary.added).toBe(1);
expect(
removedResult.items.find(
({ left_node_id }) => left_node_id === removed.node_id,
),
).toMatchObject({ status: "removed", dimensions: ["availability"] });
expect(removedResult.summary.removed).toBe(1);
expect(
compare(
[leftRoot, node("c".repeat(64), "same.js")],
[rightRoot, node("c".repeat(64), "same.js")],
).summary,
).toMatchObject({
unchanged: 2,
added: 0,
removed: 0,
expect(result.summary).toEqual({
unchanged: 1,
added: 1,
removed: 1,
changed: 0,
unknown: 2,
});
expect(result.items).toEqual(
expect.arrayContaining([
expect.objectContaining({
left_node_id: unavailable.node_id,
right_node_id: null,
status: "unknown",
dimensions: ["availability"],
limitations: [LIMITATION],
}),
expect.objectContaining({
left_node_id: null,
right_node_id: unknown.node_id,
status: "unknown",
dimensions: ["availability"],
limitations: [LIMITATION],
}),
expect.objectContaining({
left_node_id: removed.node_id,
right_node_id: null,
status: "removed",
dimensions: ["availability"],
}),
expect.objectContaining({
left_node_id: null,
right_node_id: added.node_id,
status: "added",
dimensions: ["availability"],
limitations: [LIMITATION],
}),
]),
);
});
it("does not treat unexamined source metadata as a file change", () => {