test(javascript): consolidate semantic graph coverage

This commit is contained in:
morluto committed 2026-11-17 21:02:58 -05:00
1 parent e2e3881c0e
commit c77d4261a1
17 files changed
+684 -1098

No files matched your search

@@ -1,6 +1,5 @@
import { expect, it } from "vitest";
import { completeApplicationCoverage } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
import { createJavaScriptApplicationNode } from "../../domain/javascript/javascriptApplicationGraph.js";
import { JavaScriptArtifactGraphAccumulator } from "./JavaScriptArtifactGraphAccumulator.js";
import { artifactObservationEvidence } from "./JavaScriptArtifactGraphEvidence.js";
@@ -25,73 +24,45 @@ const nodeInput = (value: string, sha256 = "a".repeat(64)) => ({
],
});
it("retains live references, exact deduplication and canonical output across later additions", () => {
it("updates held nodes and deduplicates observations across finalization", () => {
const accumulator = new JavaScriptArtifactGraphAccumulator();
const inputs = ["雪😀", "alpha", "beta"].map((value) => nodeInput(value));
const firstInput = inputs[0];
if (firstInput === undefined) throw new Error("Missing first input");
const node = accumulator.addNode(firstInput);
const observations = node.observations;
const firstObservation = observations[0];
expect(accumulator.addNode(firstInput)).toBe(node);
expect(node.observations).toBe(observations);
expect(observations).toHaveLength(1);
expect(observations[0]).not.toBe(firstObservation);
for (const input of inputs.slice(1))
expect(accumulator.addNode(input)).toBe(node);
const secondNode = accumulator.addNode(nodeInput("other", "b".repeat(64)));
const firstSnapshot = accumulator.nodes();
const expectedNode = createJavaScriptApplicationNode({
...firstInput,
observations: inputs.flatMap((input) => input.observations),
});
expect(firstSnapshot).toEqual([expectedNode, secondNode]);
expect(firstSnapshot[0]).toBe(node);
expect(node.observations).toBe(observations);
const finalizedObservations = [...observations];
expect(accumulator.nodes()).not.toBe(firstSnapshot);
expect(accumulator.nodes()).toEqual(firstSnapshot);
for (const [index, observation] of finalizedObservations.entries())
expect(node.observations[index]).toBe(observation);
const later = nodeInput("later");
expect(accumulator.addNode(later)).toBe(node);
// Updating a duplicate after final sorting must use its new array index.
expect(accumulator.addNode(firstInput)).toBe(node);
expect(accumulator.nodes()).toEqual([
createJavaScriptApplicationNode({
...firstInput,
observations: [...inputs, later].flatMap((input) => input.observations),
}),
secondNode,
]);
expect(node.observations).toBe(observations);
});
it("preserves first-input duplicates and retains the last occurrence when later merged", () => {
const accumulator = new JavaScriptArtifactGraphAccumulator();
const first = nodeInput("same");
const distinct = nodeInput("distinct");
const node = accumulator.addNode({
const first = nodeInput("雪😀");
const held = accumulator.addNode({
...first,
observations: [...first.observations, ...first.observations],
});
const observations = node.observations;
const lastInitial = observations[1];
expect(accumulator.nodes()[0]?.observations).toHaveLength(2);
expect(accumulator.addNode(distinct)).toBe(node);
expect(accumulator.nodes()).toEqual([
createJavaScriptApplicationNode({
...first,
observations: [...first.observations, ...distinct.observations],
}),
]);
expect(node.observations).toBe(observations);
expect(observations).toContain(lastInitial);
// A repeated observation inside an incoming batch also collapses to one.
const other = accumulator.addNode(nodeInput("other", "b".repeat(64)));
const alpha = nodeInput("alpha");
accumulator.addNode({
...distinct,
observations: [...distinct.observations, ...distinct.observations],
...alpha,
observations: [...alpha.observations, ...alpha.observations],
});
expect(accumulator.nodes()[0]?.observations).toHaveLength(2);
accumulator.addNode(nodeInput("beta"));
const labels = () => held.observations.map(({ label }) => label).sort();
const finalized = accumulator.nodes();
expect(labels()).toEqual(["alpha", "beta", "雪😀"]);
expect(finalized.map(({ node_id }) => node_id).toSorted()).toEqual(
[held.node_id, other.node_id].toSorted(),
);
const identifiers = held.observations.map(
({ observation_id }) => observation_id,
);
expect(identifiers).toEqual(identifiers.toSorted());
accumulator.addNode(nodeInput("later"));
accumulator.addNode(first);
expect(labels()).toEqual(["alpha", "beta", "later", "雪😀"]);
const published = accumulator.nodes();
expect(
published
.find(({ node_id }) => node_id === held.node_id)
?.observations.map(({ label }) => label)
.sort(),
).toEqual(["alpha", "beta", "later", "雪😀"]);
expect(
published
.find(({ node_id }) => node_id === other.node_id)
?.observations.map(({ label }) => label),
).toEqual(["other"]);
});
@@ -186,48 +186,36 @@ it.each([
},
);
it("keeps assignments in computed methods' parameter defaults in the method", () => {
it("keeps assignments with the callable that evaluates them inside computed methods", () => {
const graph = graphForJavaScript(`
const accel = 0.001; let speed = 6;
const obj = { ["tick"](value = (speed = accel)) { return speed; } };
const accel = 0.001; let parameterSpeed = 6; let callbackSpeed = 6; let callback;
const withDefault = { ["tick"](value = (parameterSpeed = accel)) { return parameterSpeed; } };
const withKeyCallback = { [(() => { callbackSpeed = accel; return "tick"; })()]() {} };
const withDeferredCallback = { [(callback = () => accel)]() {} };
`);
const nodes = new Map(graph.nodes.map((node) => [node.node_id, node]));
const assignment = graph.relations.find(
(edge) => edge.properties.assignment_operator === "=",
);
expect(assignment).toBeDefined();
const source = nodes.get(assignment!.source_node_id);
const target = nodes.get(assignment!.target_node_id);
expect(source?.function_node_id).toBeTypeOf("string");
expect(source?.function_node_id).toBe(target?.function_node_id);
});
it("does not treat a callback body nested in a computed key as a key-time assignment input", () => {
const graph = graphForJavaScript(`
const accel = 0.001; let callback;
const obj = { [(callback = () => accel)]() {} };
`);
expect(
graph.relations.filter(
(edge) => edge.properties.assignment_operator !== undefined,
),
).toEqual([]);
});
it("retains an assignment owned by a callback inside a computed key", () => {
const graph = graphForJavaScript(`
const accel = 0.001; let speed = 6;
const obj = { [(() => { speed = accel; return "tick"; })()]() {} };
`);
const nodes = new Map(graph.nodes.map((node) => [node.node_id, node]));
const assignment = graph.relations.find(
(edge) => edge.properties.assignment_operator === "=",
);
expect(assignment).toBeDefined();
const source = nodes.get(assignment!.source_node_id);
const target = nodes.get(assignment!.target_node_id);
expect(source?.label).toBe("accel");
expect(target?.label).toBe("speed");
expect(source?.function_node_id).toBeTypeOf("string");
expect(source?.function_node_id).toBe(target?.function_node_id);
const assignments = graph.relations
.filter(({ properties }) => properties.assignment_operator === "=")
.map(({ source_node_id, target_node_id }) => ({
source: nodes.get(source_node_id),
target: nodes.get(target_node_id),
}));
expect(assignments.map(({ target }) => target?.label).sort()).toEqual([
"callbackSpeed",
"parameterSpeed",
]);
for (const { source, target } of assignments) {
expect(source?.label).toBe("accel");
const owner = source?.function_node_id;
if (owner == null) throw new Error("Expected an assignment owner");
expect(target?.function_node_id).toBe(owner);
expect(nodes.get(owner)).toMatchObject({
kind: "function",
identity: {
source_range: {
start: { line: target?.label === "parameterSpeed" ? 3 : 4 },
},
},
});
}
});
@@ -13,11 +13,6 @@ import {
createJavaScriptSemanticGraphProjection,
projectJavaScriptSemanticFileSteps,
} from "./JavaScriptSemanticGraphBuilder.js";
import {
addSemanticGraphNode,
constructSemanticGraphNode,
createSemanticGraphProjectionState,
} from "./JavaScriptSemanticGraphConstruction.js";
import type { JavaScriptArtifactFile } from "../../domain/javascript/javascriptArtifactFiles.js";
import { queryJavaScriptSemanticGraph } from "../../domain/javascript/javascriptSemanticQuery.js";
import {
@@ -25,7 +20,6 @@ import {
analyzeParsedJavaScriptSemantics,
} from "../../domain/javascript/javascriptSemanticAnalysis.js";
import { parseJavaScriptSource } from "../../domain/javascript/javascriptSourceParser.js";
import { semanticCoverageResourceLimits } from "../../domain/javascript/javascriptSemanticCoverage.js";
import { getterExpansionSource } from "../../../tests/fixtures/javascriptGetterExpansion.js";
const SHA256 = "a".repeat(64);
@@ -56,6 +50,7 @@ it("retains direct call literals and resolves literal queries to their argument"
direction: "forward-influence",
}),
);
expect(trace.seed_node_ids).toHaveLength(1);
expect(
trace.nodes.find((node) => node.node_id === trace.seed_node_ids[0])?.label,
).toBe("argument 0");
@@ -64,9 +59,7 @@ it("retains direct call literals and resolves literal queries to their argument"
it("reports the primitive byte bound when a direct argument is too large", () => {
const source = `rpc(${JSON.stringify("x".repeat(175_000))});`;
const ir = analyzeJavaScriptSemantics(source);
expect(ir.coverage.resourceLimits).toContain("primitive-bytes");
const graph = graphFor(source, ir);
const graph = graphFor(source);
const call = graph.nodes.find(({ kind }) => kind === "call-site");
expect(call?.properties.arguments).toBeUndefined();
expect(graph.coverage.status).not.toBe("complete");
@@ -267,16 +260,6 @@ it.each([
);
});
it("continues to project an ordinary member access as a property read", () => {
const graph = graphFor(`
const source = { count: 1 };
const value = source.count;
`);
expect(graph.relations).toContainEqual(
expect.objectContaining({ relation: "reads-property" }),
);
});
it("keeps a directly returned or passed property in backward provenance", () => {
const source = `
const settings = { index: "products" };
@@ -305,6 +288,9 @@ it("keeps a directly returned or passed property in backward provenance", () =>
const concatenated = added();
`;
const graph = graphFor(source);
expect(graph.relations).toContainEqual(
expect.objectContaining({ relation: "reads-property" }),
);
const provenance = (binding: string, candidates: boolean) => {
const node = graph.nodes.find(
(item) => item.kind === "binding" && item.label === binding,
@@ -324,99 +310,83 @@ it("keeps a directly returned or passed property in backward provenance", () =>
};
for (const binding of ["a", "b", "direct", "c", "d", "e", "g", "local"]) {
expect(provenance(binding, false), binding).toBe(true);
expect(provenance(binding, true), `${binding} candidates`).toBe(true);
}
expect(provenance("concatenated", false)).toBe(false);
expect(provenance("concatenated", true)).toBe(false);
});
it("keeps dynamic calls explicit and returns complete deterministic results", () => {
const graph = graphFor(`
const handlers = { ready() { return 1; } };
const key = process.argv[2];
handlers[key]();
`);
expect(graph.unknowns.some(({ reason }) => reason === "dynamic-call")).toBe(
true,
it("retains the unresolved call frontier at the computed call site", () => {
const graph = graphFor(
[
"const handlers = { ready() { return 1; } };",
"const key = process.argv[2];",
"handlers[key]();",
].join("\n"),
);
const seedNodeId = graph.relations.find(
({ relation }) => relation === "defines",
)?.source_node_id;
if (seedNodeId === undefined) throw new Error("Expected a definition seed");
const first = queryJavaScriptSemanticGraph(
graph,
javaScriptSemanticQueryInputSchema.parse({
seed: { kind: "semantic-node", node_id: seedNodeId },
direction: "forward-influence",
include_ambiguous_dynamic_edges: true,
}),
);
const repeated = queryJavaScriptSemanticGraph(
graph,
javaScriptSemanticQueryInputSchema.parse({
seed: { kind: "semantic-node", node_id: seedNodeId },
direction: "forward-influence",
include_ambiguous_dynamic_edges: true,
}),
);
expect(repeated).toEqual(first);
});
it("preserves primitive candidate budget unknowns in semantic graph coverage", () => {
const source = `const answer = ${primitiveCandidateExpansionExpression()};`;
const ir = analyzeJavaScriptSemantics(source);
const graph = graphFor(source, ir);
expect(ir.coverage).toMatchObject({
status: "partial",
resourceLimits: ["primitive-candidates"],
});
const module = graph.nodes.find(({ kind }) => kind === "module");
if (module === undefined) throw new Error("Expected the containing module");
expect(
graph.unknowns.filter(({ reason }) => reason === "resource-limit"),
).toEqual([
expect.objectContaining({
family: "data-flow",
reason: "resource-limit",
detail: expect.stringMatching(/primitive candidate budget exceeded/i),
}),
graph.unknowns.filter(({ reason }) => reason === "dynamic-call"),
).toMatchObject([
{
node_id: module.node_id,
family: "call-flow",
relation_kinds: ["calls"],
candidate_node_ids: [],
evidence: {
location: {
available: true,
value: {
kind: "source-range",
source: "app.js",
start: { line: 3, column: 0 },
},
},
},
},
]);
});
it("preserves derived string-byte limit reasons in semantic graph unknowns", () => {
const source = primitiveByteExpansionSource();
const ir = analyzeJavaScriptSemantics(source);
const graph = graphFor(source, ir);
expect(semanticCoverageResourceLimits(ir.coverage)).toContain(
"primitive-bytes",
const graph = graphFor(primitiveByteExpansionSource());
const answer = graph.nodes.find(
({ kind, label }) => kind === "binding" && label === "answer",
);
if (answer === undefined)
throw new Error("Expected the derived value binding");
expect(graph.unknowns).toContainEqual(
expect.objectContaining({
node_id: answer.node_id,
family: "data-flow",
relation_kinds: ["defines"],
reason: "resource-limit",
detail: expect.stringMatching(/primitive string-byte budget exceeded/i),
}),
);
});
it("retains resource-limit reasons at nested object property slots", () => {
it("retains primitive candidate exhaustion at the nested property slot", () => {
const source = `const answer = { nested: { value: ${primitiveCandidateExpansionExpression()} } };`;
const ir = analyzeJavaScriptSemantics(source);
const graph = graphFor(source, ir);
expect(semanticCoverageResourceLimits(ir.coverage)).toEqual([
"primitive-candidates",
]);
expect(graph.unknowns).toContainEqual(
expect.objectContaining({
const graph = graphFor(source);
const slot = graph.nodes.find(
({ kind, properties }) =>
kind === "property-slot" &&
properties.property_pointer === "/nested/value",
);
if (slot === undefined) throw new Error("Expected the nested property slot");
expect(
graph.unknowns.filter(({ reason }) => reason === "resource-limit"),
).toMatchObject([
{
node_id: slot.node_id,
family: "data-flow",
relation_kinds: ["defines"],
reason: "resource-limit",
detail: expect.stringMatching(
/Unknown value at property:\/nested\/value/u,
/primitive candidate budget exceeded.*Unknown value at property:\/nested\/value/iu,
),
}),
);
},
]);
});
it("preserves deep expression resource reasons through graph projection", () => {
@@ -432,12 +402,8 @@ it("preserves deep expression resource reasons through graph projection", () =>
for (let index = 0; index < 5_000; index += 1)
expression = t.unaryExpression("!", expression, true);
declarator.init = expression;
const ir = analyzeParsedJavaScriptSemantics(parsed);
const graph = graphFor(source, ir);
const graph = graphFor(source, analyzeParsedJavaScriptSemantics(parsed));
expect(semanticCoverageResourceLimits(ir.coverage)).toEqual([
"expression-depth",
]);
expect(
graph.unknowns.filter(({ reason }) => reason === "resource-limit"),
).toEqual([
@@ -769,31 +735,6 @@ it("keeps uncertain parser results as candidates and ignores shadowed coercions"
).toBe(false);
});
const semanticNodeFor = (roleKey: string) => {
const file: JavaScriptArtifactFile = {
path: "budget.js",
container_sha256: SHA256,
sha256: SHA256,
bytes: 0,
inventory_artifact_id: `art_${SHA256}`,
kind: "javascript",
unpacked: false,
text: { included: true, value: "" },
};
const state = createSemanticGraphProjectionState();
return constructSemanticGraphNode(
file,
{
kind: "expression",
roleKey,
location: null,
label: roleKey,
functionNodeId: null,
},
state,
);
};
it("preserves getter expansion limits in semantic graph coverage", () => {
const source = getterExpansionSource();
const graph = graphFor(source, analyzeJavaScriptSemantics(source));
@@ -1126,53 +1067,34 @@ it("attributes an adopted file to the ceiling that bounded its offer", () => {
expect(limitation).not.toContain("max_semantic_nodes is 10");
});
it("leaves a small application complete and untruncated", () => {
const graph = graphFor("const answer = 40 + 2;");
expect(graph.coverage.truncated).toBe(false);
expect(graph.coverage.omitted_nodes).toBe(0);
expect(graph.coverage.omitted_relations).toBe(0);
expect(graph.coverage.limits).toEqual([]);
});
it("does not mark a file truncated when it exactly fills its budget", () => {
// Each unbound reference projects one expression, plus the module root.
const graph = graphFor(
"external;\n".repeat(
JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS.semanticNodesPerFile - 1,
),
);
expect(graph.nodes).toHaveLength(
JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS.semanticNodesPerFile,
);
expect(graph.coverage).toMatchObject({
it("reports truncation only when a file exceeds its exact node budget", () => {
const sources = [{ path: "exact.js", text: "first;\nsecond;\nthird;" }];
const exact = finishSources({ totalNodes: 10, fileNodes: 4 }, sources);
expect(exact.nodes).toHaveLength(4);
expect(exact.coverage).toMatchObject({
status: "unknown",
truncated: false,
omitted_nodes: 0,
omitted_relations: 0,
limits: [],
});
});
it("only records node loss when the budget rejects a new identity", () => {
// The truncation signal must record blocked node creation, not a zero
// remaining budget: a file using exactly its share drops nothing.
const state = createSemanticGraphProjectionState();
state.fileNodeBudget = 2;
state.fileNodesDropped = false;
const first = addSemanticGraphNode(state, semanticNodeFor("first"));
const second = addSemanticGraphNode(state, semanticNodeFor("second"));
expect(first).not.toBeNull();
expect(second).not.toBeNull();
expect(state.fileNodeBudget).toBe(0);
expect(state.fileNodesDropped).toBe(false);
expect(addSemanticGraphNode(state, semanticNodeFor("first"))).toEqual(first);
expect(state.nodes.size).toBe(2);
expect(state.fileNodeBudget).toBe(0);
expect(state.fileNodesDropped).toBe(false);
const blocked = addSemanticGraphNode(state, semanticNodeFor("third"));
expect(blocked).toBeNull();
expect(state.fileNodesDropped).toBe(true);
const exceeded = finishSources({ totalNodes: 10, fileNodes: 3 }, sources);
const dropped = exact.nodes.filter(
({ identity }) => identity.source_range?.start.line === 3,
);
expect(dropped).toHaveLength(1);
expect(exceeded.nodes.map(({ node_id }) => node_id)).toEqual(
exact.nodes
.filter((node) => node !== dropped[0])
.map(({ node_id }) => node_id),
);
expect(exceeded.coverage).toMatchObject({
status: "partial",
truncated: true,
});
expect(exceeded.limitations.join("\n")).toContain(
"max_semantic_nodes_per_file is 3",
);
});
it("keeps full static property identities distinct through backward provenance", () => {
@@ -196,7 +196,7 @@ export const retainSemanticGraphNode = (
};
/** Retain one canonical semantic node. */
export const addSemanticGraphNode = (
const addSemanticGraphNode = (
state: SemanticGraphProjectionState,
node: JavaScriptSemanticGraphNode,
knownLookupKey?: string,
@@ -1,8 +1,8 @@
import { expect, it } from "vitest";
import { graphForJavaScript } from "../../../tests/fixtures/javascriptSemanticGraph.js";
it.each(
[
it("links declared and assigned destructuring bindings to their exact source slots", () => {
const cases = [
{ pattern: "{ a: selected }", source: "{ a: 1 }", path: ["a"] },
{ pattern: "[selected]", source: "[1]", path: ["0"] },
{
@@ -16,33 +16,41 @@ it.each(
path: ["a", "b"],
},
{ pattern: "[[selected] = []]", source: "[[1]]", path: ["0", "0"] },
].flatMap((pattern) =>
[false, true].map((assignment) => ({ ...pattern, assignment })),
),
)(
"retains source-property flow for $pattern, assignment=$assignment",
({ pattern, source, path, assignment }) => {
const graph = graphForJavaScript(`
const source = ${source};
${assignment ? `let selected; (${pattern} = source);` : `const ${pattern} = source;`}
`);
const target = graph.nodes.find(
(node) => node.kind === "binding" && node.label === "selected",
);
expect(target).toBeDefined();
const relations = graph.relations.filter(
(relation) =>
relation.relation === "destructures" &&
relation.target_node_id === target?.node_id,
);
expect(relations).toHaveLength(1);
expect(relations[0]?.resolution).toBe("resolved");
const slot = graph.nodes.find(
(node) => node.node_id === relations[0]?.source_node_id,
);
expect(slot?.properties.property_path).toEqual(path);
},
);
];
const graph = graphForJavaScript(
cases
.map(({ pattern, source }, index) =>
[
`const source${index} = ${source};`,
`const ${pattern.replace("selected", `declared${index}`)} = source${index};`,
`let assigned${index};`,
`(${pattern.replace("selected", `assigned${index}`)} = source${index});`,
].join("\n"),
)
.join("\n"),
);
const nodes = new Map(graph.nodes.map((node) => [node.node_id, node]));
expect(
graph.relations
.filter(({ relation }) => relation === "destructures")
.map(({ source_node_id, target_node_id, resolution }) => ({
target: nodes.get(target_node_id)?.label,
path: nodes.get(source_node_id)?.properties.property_path,
resolution,
}))
.sort((left, right) =>
String(left.target).localeCompare(String(right.target)),
),
).toEqual(
["assigned", "declared"].flatMap((form) =>
cases.map(({ path }, index) => ({
target: `${form}${index}`,
path,
resolution: "resolved",
})),
),
);
});
it.each(["{}", "unknownSource"])(
"keeps nested default source flow conservative for %s",
@@ -2,7 +2,10 @@ import { expect, it } from "vitest";
import { analyzeJavaScriptStaticSource } from "../../../tests/fixtures/javascriptStaticAnalysis.js";
import { analyzeJavaScriptSemantics } from "../../domain/javascript/javascriptSemanticAnalysis.js";
import type { JavaScriptArtifactFile } from "../../domain/javascript/javascriptArtifactFiles.js";
import { projectJavaScriptSemanticFileSteps } from "./JavaScriptSemanticGraphBuilder.js";
import {
createJavaScriptSemanticGraphProjection,
projectJavaScriptSemanticFileSteps,
} from "./JavaScriptSemanticGraphBuilder.js";
const source = `${Array.from({ length: 40 }, (_, i) => `function library${String(i)}(){return ${String(i)}}`).join("\n")}
const e=require("electron");
@@ -20,53 +23,53 @@ const file: JavaScriptArtifactFile = {
};
const facts = analyzeJavaScriptStaticSource(source);
const ir = analyzeJavaScriptSemantics(source);
const project = (budget: number) => {
const steps = projectJavaScriptSemanticFileSteps(
file,
ir,
{ nodes: budget, unknowns: budget },
facts.electron.call_paths,
);
let result = steps.next();
while (!result.done) result = steps.next();
return result.value;
};
it("retains Electron boundary evidence until the node budget cuts the path", () => {
for (const budget of [3, 20]) {
const projection = createJavaScriptSemanticGraphProjection({
totalNodes: budget,
fileNodes: budget,
});
const steps = projectJavaScriptSemanticFileSteps(
file,
ir,
projection.remainingFileCapacity(),
facts.electron.call_paths,
);
let result = steps.next();
while (!result.done) result = steps.next();
projection.adoptFileProjection(result.value);
const graph = projection.finish(file.container_sha256, {
graph_id: `jag_${"c".repeat(64)}`,
nodes: [],
});
it("retains Electron calls before library definitions consume the node budget", () => {
const result = project(20);
expect(result.nodes).toHaveLength(20);
expect(result.nodesTruncated).toBe(true);
const terminal = result.nodes.find(
(node) => node.label === "ipc-event.sender.copy",
);
expect(terminal).toBeDefined();
expect(
result.relations.some(
(r) =>
r.target_node_id === terminal?.node_id && r.resolution === "candidate",
),
).toBe(true);
expect(
result.nodes.some(
(node) =>
node.properties.entry === "test:copy" &&
Array.isArray(node.properties.conditions) &&
node.properties.conditions.length === 1,
),
).toBe(true);
});
it("reports truncation and keeps referential integrity even within a boundary path", () => {
const result = project(3);
expect(result.nodes).toHaveLength(3);
expect(result.nodesTruncated).toBe(true);
expect(
result.nodes.some((node) => node.label === "ipc-event.sender.copy"),
).toBe(false);
const retained = new Set(result.nodes.map((node) => node.node_id));
expect(
result.relations.every(
(r) => retained.has(r.source_node_id) && retained.has(r.target_node_id),
),
).toBe(true);
expect(graph.nodes).toHaveLength(budget);
expect(graph.coverage).toMatchObject({
status: "partial",
truncated: true,
});
const terminal = graph.nodes.find(
({ label }) => label === "ipc-event.sender.copy",
);
if (budget === 3) {
expect(terminal).toBeUndefined();
continue;
}
if (terminal === undefined)
throw new Error("Expected the Electron terminal");
expect(graph.relations).toContainEqual(
expect.objectContaining({
target_node_id: terminal.node_id,
resolution: "candidate",
}),
);
expect(graph.nodes).toContainEqual(
expect.objectContaining({
properties: expect.objectContaining({
entry: "test:copy",
conditions: [expect.anything()],
}),
}),
);
}
});
@@ -201,23 +201,6 @@ it("keeps sequence side effects unknown instead of attributing earlier values di
).toBe(true);
});
it("seeds a direct argument at its occurrence and reaches the call", () => {
const graph = graphForJavaScript('consume("only-direct");');
const result = queryJavaScriptSemanticGraph(
graph,
javaScriptSemanticQueryInputSchema.parse({
seed: { kind: "literal", value: "only-direct" },
direction: "forward-influence",
}),
);
expect(result.summary.total_seed_matches).toBe(1);
expect(
result.nodes.find((node) => node.node_id === result.seed_node_ids[0])
?.label,
).toBe("argument 0");
expect(result.nodes.some((node) => node.kind === "call-site")).toBe(true);
});
it("keeps older call-site literal evidence searchable when argument literals are absent", () => {
const graph = graphForJavaScript('consume("only-direct");');
const legacy = {
@@ -9,25 +9,21 @@ import { resolveJavaScriptSemanticEvidence } from "../../../tests/support/javasc
const SHA256 = "a".repeat(64);
const GRAPH_ID = `jag_${"b".repeat(64)}`;
it("projects literal events and exact timer cancellation", () => {
it("keeps literal event links and dynamic event uncertainty", () => {
const graph = graphFor(`
function run(bus, dynamicName) {
const handle = setInterval(tick, 10);
bus.on("ready", handler);
bus.once(dynamicName, handler);
bus.emit("ready");
bus.removeListener("ready", handler);
clearInterval(handle);
}
`);
const relations = new Set(graph.relations.map(({ relation }) => relation));
for (const expected of [
"cancels-timer",
"dispatches-candidate",
"registers-listener",
"removes-listener",
"schedules-timer",
] as const)
expect(relations.has(expected)).toBe(true);
expect(
@@ -45,9 +41,6 @@ it("projects literal events and exact timer cancellation", () => {
expect(
graph.coverage.families.find(({ family }) => family === "event"),
).toMatchObject({ status: "partial" });
expect(
graph.coverage.families.find(({ family }) => family === "timer"),
).toMatchObject({ status: "partial" });
});
it("projects child-process creation, I/O, listeners, and signals", () => {
@@ -65,32 +58,41 @@ it("projects child-process creation, I/O, listeners, and signals", () => {
}
`);
const relations = new Set(graph.relations.map(({ relation }) => relation));
for (const expected of [
"connects-stdio",
"forwards-signal",
"listens-error",
"listens-exit",
"spawns",
"supplies-argv",
"supplies-env",
] as const)
expect(relations.has(expected)).toBe(true);
const child = graph.nodes.find(({ kind }) => kind === "child-process");
if (child === undefined) throw new Error("Expected the spawned child");
expect(child.properties).toMatchObject({
method: "spawn",
command: null,
argv_count: 2,
environment_supplied: true,
stdio_mode: "pipe",
});
expect(
graph.nodes.find(
({ kind, properties }) =>
kind === "child-process" &&
properties.method === "spawn" &&
properties.command === null,
),
).toBeDefined();
graph.relations
.filter(({ target_node_id }) => target_node_id === child.node_id)
.map(({ relation }) => relation),
).toEqual(
expect.arrayContaining([
"forwards-signal",
"spawns",
"supplies-argv",
"supplies-env",
]),
);
expect(
graph.unknowns.some(
({ family, detail }) =>
family === "child-process" &&
detail.includes("command remains unresolved"),
),
).toBe(true);
graph.relations
.filter(({ source_node_id }) => source_node_id === child.node_id)
.map(({ relation }) => relation),
).toEqual(
expect.arrayContaining(["connects-stdio", "listens-error", "listens-exit"]),
);
expect(graph.unknowns).toContainEqual(
expect.objectContaining({
node_id: child.node_id,
family: "child-process",
detail: expect.stringContaining("command remains unresolved"),
}),
);
expect(
graph.coverage.families.find(({ family }) => family === "child-process"),
).toMatchObject({ status: "partial" });
@@ -231,18 +233,48 @@ it("projects built-in resource acquisition and release", () => {
).toMatchObject({ status: "partial" });
});
it.each(["+= 1", "++"])(
"projects both property dependencies for %s",
(operator) => {
const graph = graphFor(`
const source = { count: 1 };
source.count ${operator};
`);
const relations = graph.relations.map(({ relation }) => relation);
expect(relations).toContain("reads-property");
expect(relations).toContain("writes-property");
},
);
it("links the read and write of each update to the same property slot", () => {
const graph = graphFor(`
const source = { count: 1, total: 2 };
source.count += 1;
source.total++;
`);
for (const path of ["count", "total"]) {
const slot = graph.nodes.find(
({ kind, properties }) =>
kind === "property-slot" && properties.property_pointer === `/${path}`,
);
if (slot === undefined) throw new Error(`Expected the ${path} slot`);
const updates = graph.nodes.filter(
({ properties }) =>
Array.isArray(properties.property_path) &&
properties.property_path[0] === path,
);
const read = updates.find(
({ properties }) => properties.operation_kind === "read",
);
const write = updates.find(
({ properties }) => properties.operation_kind === "write",
);
if (read === undefined || write === undefined)
throw new Error(`Expected both operations for ${path}`);
expect(graph.relations).toEqual(
expect.arrayContaining([
expect.objectContaining({
relation: "reads-property",
source_node_id: slot.node_id,
target_node_id: read.node_id,
}),
expect.objectContaining({
relation: "writes-property",
source_node_id: write.node_id,
target_node_id: slot.node_id,
}),
]),
);
}
});
it("does not project a literal property slot for dynamic destructuring", () => {
const graph = graphFor(`
const source = { token: "TOKEN" };
@@ -1,105 +1,48 @@
import { expect, it } from "vitest";
import { graphForJavaScript as graphFor } from "../../../tests/fixtures/javascriptSemanticGraph.js";
import { analyzeJavaScriptSemantics } from "../../domain/javascript/javascriptSemanticAnalysis.js";
import { topLevelBinding } from "../../domain/javascript/javascriptSemanticAnalysis.fixture.js";
import { graphForJavaScript } from "../../../tests/fixtures/javascriptSemanticGraph.js";
const dynamicScopeUnknowns = (source: string) =>
graphFor(source).unknowns.filter(({ reason }) => reason === "dynamic-scope");
it("exposes direct eval and with as dynamic-scope unknowns in the public graph", () => {
const unknowns = dynamicScopeUnknowns(`
function inspect(host, source) {
with (host) { consume(target); }
eval(source);
}
`);
it("records dynamic scope only at with and unshadowed direct eval", () => {
const graph = graphForJavaScript(
[
"function inspect(host, source) {",
" with (host) { consume(target); }",
" eval(source);",
"}",
"function shadowed(eval, source) { eval(source); }",
"function optional(source) { eval?.(source); }",
"function indirect(source) { (0, eval)(source); }",
].join("\n"),
);
const inspect = graph.nodes.find(
({ label, kind }) => kind === "function" && label === "inspect",
);
if (inspect === undefined)
throw new Error("Expected the containing function");
const unknowns = graph.unknowns.filter(
({ reason }) => reason === "dynamic-scope",
);
expect(unknowns).toHaveLength(2);
expect(unknowns.map(({ detail }) => detail).join("\n")).toEqual(
expect.stringContaining("with"),
);
expect(unknowns.map(({ detail }) => detail).join("\n")).toEqual(
expect.stringContaining("eval"),
);
});
it("does not mark shadowed, optional, or indirect eval as dynamic scope", () => {
const unknowns = dynamicScopeUnknowns(`
function shadowed(eval, source) { eval(source); }
function optional(source) { eval?.(source); }
function indirect(source) { (0, eval)(source); }
`);
expect(unknowns).toEqual([]);
});
it("keeps switch discriminants outside the shared case lexical scope", () => {
const ir = analyzeJavaScriptSemantics(`
const selected = choose();
switch (selected) {
case 1: let selected = 1; let local = 1; break;
case 2: local = 2; break;
}
`);
const selectedBinding = topLevelBinding(ir, "selected");
const localBindings = ir.bindings.filter(({ name }) => name === "local");
expect(ir.references.find(({ name }) => name === "selected")?.bindingId).toBe(
selectedBinding.bindingId,
);
expect(localBindings).toHaveLength(1);
expect(localBindings[0]?.scopeId).not.toBe(selectedBinding?.scopeId);
expect(
ir.references.filter(
({ name, role }) => name === "selected" && role === "read",
),
).toHaveLength(1);
expect(
ir.references.filter(
({ name, role }) => name === "local" && role === "write",
),
).toHaveLength(1);
});
it("leaves with-object resolution intact and marks only body name resolution unknown", () => {
const ir = analyzeJavaScriptSemantics(`
const host = getHost();
const outer = 3;
function inspect() {
with (host) {
const local = 1;
consume(local, outer);
}
}
`);
const host = topLevelBinding(ir, "host");
const hostRead = ir.references.find(
({ name, role }) => name === "host" && role === "read",
);
const outerRead = ir.references.find(
({ name, role }) => name === "outer" && role === "read",
);
const localRead = ir.references.find(
({ name, role }) => name === "local" && role === "read",
);
expect(hostRead?.bindingId).toBe(host.bindingId);
expect(hostRead?.resolution).toBe("resolved");
expect(outerRead?.resolution).toBe("unknown");
expect(localRead?.resolution).toBe("resolved");
expect(outerRead?.bindingId).toBeNull();
});
it("keeps var declarations in each static block from leaking to another block", () => {
const ir = analyzeJavaScriptSemantics(`
class Example {
static { var first = 1; }
static { var second = 2; consume(first); }
}
`);
const first = ir.bindings.filter(({ name }) => name === "first");
const second = ir.bindings.filter(({ name }) => name === "second");
expect(ir.references.find(({ name }) => name === "first")?.resolution).toBe(
"unbound",
);
expect(first).toHaveLength(1);
expect(second).toHaveLength(1);
expect(first[0]?.scopeId).not.toBe(second[0]?.scopeId);
for (const [statement, line] of [
["with", 2],
["eval", 3],
] as const) {
expect(unknowns).toContainEqual(
expect.objectContaining({
node_id: inspect.node_id,
family: "data-flow",
relation_kinds: ["reads", "writes"],
detail: expect.stringContaining(`\`${statement}\``),
evidence: expect.objectContaining({
location: expect.objectContaining({
available: true,
value: expect.objectContaining({
kind: "source-range",
start: { line, column: 2 },
}),
}),
}),
}),
);
}
});
@@ -64,26 +64,3 @@ it("keeps resolved property seeds on their slot without duplicating access occur
graph.nodes.find(({ node_id }) => node_id === trace.seed_node_ids[0])?.kind,
).toBe("property-slot");
});
it("queries an empty event name as an exact retained event identity", () => {
const graph = graphForJavaScript(
'const { EventEmitter } = require("node:events"); const bus = new EventEmitter(); bus.on("", function emptyListener() {}); bus.on("data", function dataListener() {});',
);
const trace = queryJavaScriptSemanticGraph(
graph,
javaScriptSemanticQueryInputSchema.parse({
seed: { kind: "event", name: "" },
direction: "forward-influence",
}),
);
expect(trace.seed_node_ids.length).toBeGreaterThan(0);
const seeds = trace.nodes.filter(({ node_id }) =>
trace.seed_node_ids.includes(node_id),
);
expect(seeds.map(({ node_id }) => node_id).sort()).toEqual(
[...trace.seed_node_ids].sort(),
);
expect(seeds.every(({ properties }) => properties.event_name === "")).toBe(
true,
);
});
@@ -6,10 +6,8 @@ import {
createJavaScriptApplicationGraph,
createJavaScriptApplicationNode,
mergeJavaScriptApplicationNodes,
javascriptApplicationGraphSchema,
parseJavaScriptApplicationGraph,
serializeJavaScriptApplicationGraph,
type JavaScriptApplicationGraph,
} from "./javascriptApplicationGraph.js";
import {
APPLICATION_GRAPH_DIGESTS,
@@ -35,6 +33,10 @@ 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 merged = mergeJavaScriptApplicationNodes([
first,
{ ...second, identity: reversedIdentity },
@@ -77,13 +79,19 @@ it.each(["kind", "identity"] as const)(
},
);
const createLargeNativeExportGraph = (): JavaScriptApplicationGraph => {
const properties = Object.fromEntries(
Array.from({ length: 1_001 }, (_, index) => [
`${"export-property-"}${"k".repeat(120)}-${index}`,
"v".repeat(4_097),
]),
);
it("preserves deep and wide observation properties in a large native-export graph", () => {
let nested: unknown = "leaf";
for (let index = 0; index < 12; index += 1)
nested = { [`level-${index}`]: nested };
const largeKey = `export-property-${"k".repeat(120)}`;
const properties = {
...Object.fromEntries(
Array.from({ length: 1_000 }, (_, index) => [`symbol-${index}`, index]),
),
[largeKey]: "v".repeat(4_097),
nested,
};
const longLabel = "large export graph label ".repeat(300);
const nodes = Array.from({ length: 1_001 }, (_, index) => {
const path = `native/exports/${index}.symbol`;
return createJavaScriptApplicationNode({
@@ -96,7 +104,7 @@ const createLargeNativeExportGraph = (): JavaScriptApplicationGraph => {
},
observations: [
{
label: index === 0 ? "large export graph label ".repeat(300) : path,
label: index === 0 ? longLabel : path,
properties: index === 0 ? properties : {},
evidence: artifactEvidence(
APPLICATION_GRAPH_DIGESTS.nativeAddon,
@@ -107,69 +115,27 @@ const createLargeNativeExportGraph = (): JavaScriptApplicationGraph => {
],
});
});
const first = nodes[0];
if (first === undefined) throw new TypeError("Missing native export");
return createJavaScriptApplicationGraph({
const first = firstOf(nodes, "native export");
const graph = createJavaScriptApplicationGraph({
schema: "JavaScriptApplicationGraph",
root_node_ids: [first.node_id],
nodes,
edges: [],
coverage: {
status: "complete",
truncated: false,
omitted_count: 0,
limits: [],
},
coverage: completeCoverage,
limitations: [],
});
};
const loaded = parseJavaScriptApplicationGraph(
JSON.parse(serializeJavaScriptApplicationGraph(graph)),
);
it("accepts deeply nested canonical application properties", () => {
let nested: unknown = "leaf";
for (let index = 0; index < 12; index += 1)
nested = { [`level-${String(index)}`]: nested };
const node = createJavaScriptApplicationNode({
kind: "native-export",
identity: {
strategy: "canonical-path",
stability: "artifact-version",
artifact_sha256: APPLICATION_GRAPH_DIGESTS.nativeAddon,
path: "native/deep-export",
},
observations: [
{
label: "deep export",
properties: { nested },
evidence: artifactEvidence(
APPLICATION_GRAPH_DIGESTS.nativeAddon,
"native/deep-export",
"native-analysis-provider",
),
},
],
});
const graph = createJavaScriptApplicationGraph({
schema: "JavaScriptApplicationGraph",
root_node_ids: [node.node_id],
nodes: [node],
edges: [],
coverage: {
status: "complete",
truncated: false,
omitted_count: 0,
limits: [],
},
limitations: [],
});
expect(graph.nodes[0]?.observations[0]?.properties).toEqual({ nested });
expect(
parseJavaScriptApplicationGraph(
JSON.parse(serializeJavaScriptApplicationGraph(graph)),
),
).toEqual(graph);
expect(loaded.nodes.map(({ node_id }) => node_id).toSorted()).toEqual(
nodes.map(({ node_id }) => node_id).toSorted(),
);
const observation = loaded.nodes.find(
({ node_id }) => node_id === first.node_id,
)?.observations[0];
expect(observation?.label).toBe(longLabel);
expect(observation?.properties).toEqual(properties);
});
describe("JavaScript Application Graph: vocabulary", () => {
@@ -193,20 +159,6 @@ describe("JavaScript Application Graph: vocabulary", () => {
}),
).toEqual(graph);
});
it("keeps large native-export graphs and their complete properties", () => {
const graph = createLargeNativeExportGraph();
const largeExport = graph.nodes.find(({ observations }) =>
observations.some(({ label }) =>
label?.startsWith("large export graph label "),
),
);
expect(graph.nodes).toHaveLength(1_001);
expect(
Object.keys(largeExport?.observations[0]?.properties ?? {}),
).toHaveLength(1_001);
});
});
describe("JavaScript Application Graph: evidence authority", () => {
@@ -247,80 +199,51 @@ describe("JavaScript Application Graph: evidence authority", () => {
expect(preload.node_id).not.toBe(runtime.node_id);
});
it("retains explicit unknown observations without using them as identity proof", () => {
const node = createJavaScriptApplicationNode({
kind: "javascript-module",
identity: {
strategy: "content-digest",
stability: "global-exact",
sha256: APPLICATION_GRAPH_DIGESTS.asar,
},
observations: [
{
label: "observed module",
properties: {},
evidence: artifactEvidence(
APPLICATION_GRAPH_DIGESTS.asar,
"dist/module.js",
),
},
{
label: null,
properties: { question: "runtime correspondence" },
evidence: unknownEvidence(),
},
],
});
const graph = graphForNode(node);
expect(
graph.nodes[0]?.observations.find(
({ evidence }) => evidence.state === "unknown",
)?.evidence,
).toMatchObject({ authority: "unknown", confidence: "unknown" });
});
it("separates stable entity identity from changing observations", () => {
it("retains unknown observations but requires observed proof for an observation-scoped identity", () => {
const identity = {
strategy: "canonical-path" as const,
stability: "artifact-version" as const,
artifact_sha256: APPLICATION_GRAPH_DIGESTS.asar,
path: "dist/chunk.js",
strategy: "observation-fingerprint",
stability: "observation-only",
observation_sha256: "8".repeat(64),
scope: "synthetic static inventory",
};
const first = createJavaScriptApplicationNode({
kind: "javascript-chunk",
const unknown = {
label: null,
properties: { question: "runtime correspondence" },
evidence: unknownEvidence(),
};
const observed = {
label: "unclassified entity",
properties: {},
evidence: artifactEvidence(
APPLICATION_GRAPH_DIGESTS.asar,
"dist/module.js",
),
};
const node = createJavaScriptApplicationNode({
kind: "unknown",
identity,
observations: [
{
label: "first label",
properties: { modules: 10 },
evidence: artifactEvidence(
APPLICATION_GRAPH_DIGESTS.asar,
"dist/chunk.js",
"ast-static-analysis",
),
},
],
});
const second = createJavaScriptApplicationNode({
kind: "javascript-chunk",
identity,
observations: [
{
label: "renamed chunk",
properties: { modules: 11 },
evidence: artifactEvidence(
APPLICATION_GRAPH_DIGESTS.asar,
"dist/chunk.js",
"ast-static-analysis",
),
},
],
observations: [observed, unknown],
});
expect(first.node_id).toBe(second.node_id);
expect(first.observations[0]?.observation_id).not.toBe(
second.observations[0]?.observation_id,
expect(graphForNode(node).nodes[0]?.observations).toEqual(
expect.arrayContaining([
expect.objectContaining({
properties: { question: "runtime correspondence" },
evidence: expect.objectContaining({
state: "unknown",
authority: "unknown",
confidence: "unknown",
}),
}),
]),
);
const unsupported = createJavaScriptApplicationNode({
kind: "unknown",
identity,
observations: [unknown],
});
expect(() => graphForNode(unsupported)).toThrow(
/identity is not supported/u,
);
});
});
@@ -444,7 +367,7 @@ describe("JavaScript Application Graph: identity and evidence", () => {
});
describe("JavaScript Application Graph: source maps and observations", () => {
it("admits source-map and observation-scoped identities only with supporting observations", () => {
it("requires source-map observations to retain the declaration and map location", () => {
const sourceModule = createJavaScriptApplicationNode({
kind: "source-module",
identity: {
@@ -472,28 +395,7 @@ describe("JavaScript Application Graph: source maps and observations", () => {
},
],
});
const observationScoped = createJavaScriptApplicationNode({
kind: "unknown",
identity: {
strategy: "observation-fingerprint",
stability: "observation-only",
observation_sha256: "8".repeat(64),
scope: "synthetic static inventory",
},
observations: [
{
label: "unclassified entity",
properties: {},
evidence: artifactEvidence(
APPLICATION_GRAPH_DIGESTS.asar,
"dist/app.js",
),
},
],
});
expect(graphForNode(sourceModule).nodes).toEqual([sourceModule]);
expect(graphForNode(observationScoped).nodes).toEqual([observationScoped]);
const sourceObservation = firstOf(
sourceModule.observations,
"source observation",
@@ -604,9 +506,6 @@ describe("JavaScript Application Graph: source-map digest consistency", () => {
expect(() => graphForNode(sourceMapNode(null, null, true))).toThrow(
/Source-map observation/u,
);
expect(() =>
graphForNode(sourceMapNode("3".repeat(64), "3".repeat(64), undefined)),
).not.toThrow();
});
});
@@ -643,19 +542,8 @@ describe("JavaScript Application Graph: commitments and schemas", () => {
expect(() => parseJavaScriptApplicationGraph(staleEdge)).toThrow(
/Edge identifier/u,
);
});
it("creates exactly the graph the public schema accepts", () => {
const graph = buildSyntheticJavaScriptApplicationGraph();
expect(JSON.stringify(graph)).toBe(
JSON.stringify(
javascriptApplicationGraphSchema.parse(structuredClone(graph)),
),
);
const { graph_id: _graphId, ...semantic } = structuredClone(graph);
firstOf(semantic.edges, "edge").edge_id = `jag_edge_${"f".repeat(64)}`;
expect(() => createJavaScriptApplicationGraph(semantic)).toThrow(
const { graph_id: _graphId, ...staleInput } = staleEdge;
expect(() => createJavaScriptApplicationGraph(staleInput)).toThrow(
/Edge identifier/u,
);
});
@@ -978,7 +866,7 @@ describe("JavaScript Application Graph: identity strategy requirements", () => {
});
describe("JavaScript Application Graph: truncation claims", () => {
it("rejects false truncation claims and accepts large properties", () => {
it("rejects false truncation and incomplete-coverage claims", () => {
const truncated = artifactEvidence(
APPLICATION_GRAPH_DIGESTS.asar,
"dist/module.js",
@@ -1023,15 +911,5 @@ describe("JavaScript Application Graph: truncation claims", () => {
limitations: [],
}),
).toThrow(/Non-complete graph coverage requires an explicit limitation/u);
const properties = Object.fromEntries(
Array.from({ length: 65 }, (_, index) => [`key-${String(index)}`, index]),
);
expect(
contentNode(
artifactEvidence(APPLICATION_GRAPH_DIGESTS.asar, "dist/module.js"),
properties,
).observations[0]?.properties,
).toEqual(properties);
});
});
@@ -765,19 +765,32 @@ describe("JavaScript semantic analysis: write references", () => {
});
describe("JavaScript semantic analysis: dynamic and case scopes", () => {
it("marks with and eval as unresolved dynamic scope instead of staying silent", () => {
it("resolves with receivers and local bindings while leaving outer reads unknown", () => {
const ir = analyzeJavaScriptSemantics(`
function load(source) {
with (host) { consume(target); }
eval("var injected = 1;");
const host = getHost();
const outer = 3;
function inspect() {
with (host) {
const local = 1;
consume(local, outer);
}
}
`);
const reasons = ir.frontiers
.filter(({ kind }) => kind === "dynamic-scope")
.map(({ reason }) => reason);
expect(reasons).toHaveLength(2);
expect(reasons.join("\n")).toContain("`with`");
expect(reasons.join("\n")).toContain("`eval`");
const host = topLevelBinding(ir, "host");
const hostRead = ir.references.find(
({ name, role }) => name === "host" && role === "read",
);
const outerRead = ir.references.find(
({ name, role }) => name === "outer" && role === "read",
);
const localRead = ir.references.find(
({ name, role }) => name === "local" && role === "read",
);
expect(hostRead?.bindingId).toBe(host.bindingId);
expect(hostRead?.resolution).toBe("resolved");
expect(outerRead?.resolution).toBe("unknown");
expect(localRead?.resolution).toBe("resolved");
expect(outerRead?.bindingId).toBeNull();
});
it("does not assign CommonJS exports to lexically shadowed module or exports", () => {
@@ -795,30 +808,53 @@ describe("JavaScript semantic analysis: dynamic and case scopes", () => {
).toEqual([]);
});
it("shares one lexical scope across switch cases and isolates static blocks", () => {
const switchIr = analyzeJavaScriptSemantics(`
const kind = select();
switch (kind) {
case "a": let shared = 1; break;
case "b": shared = 2; break;
it("resolves a switch discriminant outside the case scope and writes across cases", () => {
const ir = analyzeJavaScriptSemantics(`
const selected = choose();
switch (selected) {
case 1: let selected = 1; let shared = 1; break;
case 2: shared = 2; break;
}
`);
// One declaration, one binding — and it belongs to a scope of its own, so
// it cannot leak past the switch statement.
const shared = switchIr.bindings.filter(({ name }) => name === "shared");
const outer = topLevelBinding(ir, "selected");
const shared = bindingsNamed(ir, "shared");
expect(shared).toHaveLength(1);
expect(shared[0]?.scopeId).not.toBe(
topLevelBinding(switchIr, "kind").scopeId,
expect(shared[0]?.scopeId).not.toBe(outer.scopeId);
expect(
ir.references.filter(({ name }) => name === "selected"),
).toMatchObject([
{ role: "read", resolution: "resolved", bindingId: outer.bindingId },
]);
expect(ir.references.filter(({ name }) => name === "shared")).toMatchObject(
[
{
role: "write",
resolution: "resolved",
bindingId: shared[0]?.bindingId,
},
],
);
const classIr = analyzeJavaScriptSemantics(`
});
it("isolates let and var bindings between static blocks", () => {
const ir = analyzeJavaScriptSemantics(`
class Holder {
static { let isolated = 1; }
static { let isolated = 2; }
static { let isolated = 1; var first = 1; }
static { let isolated = 2; var second = 2; consume(first); }
}
`);
expect(
classIr.bindings.filter(({ name }) => name === "isolated"),
).toHaveLength(2);
const lexical = bindingsNamed(ir, "isolated");
const first = bindingsNamed(ir, "first");
const second = bindingsNamed(ir, "second");
expect(lexical).toHaveLength(2);
expect(lexical[0]?.scopeId).not.toBe(lexical[1]?.scopeId);
expect(first).toHaveLength(1);
expect(second).toHaveLength(1);
expect(first[0]?.scopeId).not.toBe(second[0]?.scopeId);
expect(ir.references.find(({ name }) => name === "first")).toMatchObject({
resolution: "unbound",
bindingId: null,
});
});
it("keeps function, class, and method identities separate from bindings", () => {
@@ -11,7 +11,6 @@ import { z } from "zod";
import { digestCanonicalValue } from "../canonicalDigest.js";
import type { JsonValue } from "../jsonValue.js";
import type { ApplicationGraphEvidence } from "./javascriptApplicationEvidenceSchemas.js";
import {
JAVASCRIPT_SEMANTIC_RELATION_FAMILIES,
JAVASCRIPT_SEMANTIC_RELATION_FAMILY,
@@ -38,7 +37,7 @@ import { queryJavaScriptSemanticGraph } from "./javascriptSemanticQuery.js";
const SHA = "a".repeat(64);
it.each(["unknown", "unavailable", "partial"] as const)(
it.each(["unknown", "partial"] as const)(
"rejects contradictory truncated %s graph coverage",
(status) => {
const input = semanticFixtureInput();
@@ -63,24 +62,6 @@ it.each(["unknown", "unavailable", "partial"] as const)(
},
);
it("accepts truncated partial coverage with unknown omission extents", () => {
const input = semanticFixtureInput();
expect(
createJavaScriptSemanticGraph({
...input,
coverage: {
...input.coverage,
status: "partial",
truncated: true,
omitted_nodes: null,
omitted_relations: null,
limits: [{ name: "nodes", value: 1, unit: "items" }],
},
limitations: ["Node ceiling left semantic omission extents unknown."],
}).coverage,
).toMatchObject({ status: "partial", truncated: true });
});
it("accepts omitted unknown occurrences as the reason for semantic truncation", () => {
const input = semanticFixtureInput();
const family = input.coverage.families[0]!.family;
@@ -106,6 +87,9 @@ it("accepts omitted unknown occurrences as the reason for semantic truncation",
truncated: true,
omitted_nodes: 0,
omitted_relations: 0,
omitted_unknown_occurrences: [
{ family, reason: "resource-limit", occurrences: 1 },
],
});
});
const node = (
@@ -475,17 +459,6 @@ it("counts candidate ownership cycles once and traverses them finitely", () => {
).toBe("found");
});
it("defines every required relation family and canonicalizes records", () => {
expect(JAVASCRIPT_SEMANTIC_RELATIONS).toContain("argument-to-parameter");
expect(JAVASCRIPT_SEMANTIC_RELATIONS).toContain("detaches-task");
expect(JAVASCRIPT_SEMANTIC_RELATIONS).toContain("forwards-signal");
expect(JAVASCRIPT_SEMANTIC_RELATIONS).toContain("validates");
const graph = semanticFixtureGraph();
expect(graph.nodes.map(({ node_id }) => node_id)).toEqual(
graph.nodes.map(({ node_id }) => node_id).toSorted(),
);
});
it("rejects stale identities, dangling endpoints, and incomplete coverage claims", () => {
const graph = semanticFixtureGraph();
expect(() =>
@@ -545,29 +518,7 @@ it("rejects stale identities, dangling endpoints, and incomplete coverage claims
it("rejects complete family coverage with an unlisted retained frontier", () => {
const input = semanticFixtureInput(true);
input.coverage = {
...input.coverage,
status: "complete",
truncated: false,
omitted_nodes: 0,
omitted_relations: 0,
families: input.coverage.families.map((family) =>
family.family === "call-flow"
? {
...family,
status: "complete",
omitted_relations: 0,
unknown_ids: [],
}
: family,
),
};
input.limitations = [];
expect(() => createJavaScriptSemanticGraph(input)).toThrow(
/Complete family coverage cannot omit or retain unknown facts/u,
);
const valid = createJavaScriptSemanticGraph(semanticFixtureInput(true));
const valid = createJavaScriptSemanticGraph(input);
const coverage = {
...valid.coverage,
status: "complete" as const,
@@ -594,45 +545,26 @@ it("rejects complete family coverage with an unlisted retained frontier", () =>
"JavaScript semantic graph",
)}`,
};
const parsed = javaScriptSemanticGraphSchema.safeParse(invalid);
expect(parsed.success).toBe(false);
const diagnostic =
"Complete family coverage cannot omit or retain unknown facts";
expect(() => createJavaScriptSemanticGraph(changed)).toThrow(diagnostic);
const parsed = javaScriptSemanticGraphSchema.safeParse(
JSON.parse(JSON.stringify(invalid)),
);
if (parsed.success) throw new Error("Expected inconsistent graph rejection");
expect(parsed.error.issues.map(({ message }) => message)).toContain(
"Complete family coverage cannot omit or retain unknown facts",
diagnostic,
);
expect(
javaScriptSemanticGraphSchema.safeParse(JSON.parse(JSON.stringify(invalid)))
.success,
).toBe(false);
});
it("validates evidence context ownership and references", () => {
const graph = semanticFixtureGraph();
const alteredContext = {
...graph,
evidence_contexts: graph.evidence_contexts.map((context, index) =>
index === 0
? { ...context, context_id: `jsrg_evidence_${"f".repeat(64)}` }
: context,
),
};
const alteredIssues = javaScriptSemanticGraphSchema.safeParse(alteredContext);
expect(alteredIssues.success).toBe(false);
if (alteredIssues.success) throw new Error("Expected invalid context digest");
expect(alteredIssues.error.issues.map(({ message }) => message)).toContain(
"Evidence context identifier is stale",
);
expect(alteredIssues.error.issues.map(({ message }) => message)).toContain(
"Evidence reference names an absent context",
);
const changedPayload = javaScriptSemanticGraphSchema.safeParse({
...graph,
evidence_contexts: graph.evidence_contexts.map((context, index) =>
index === 0 ? { ...context, authority: "user-assertion" } : context,
),
});
expect(changedPayload.success).toBe(false);
if (changedPayload.success)
throw new Error("Expected changed context payload rejection");
expect(changedPayload.error.issues.map(({ message }) => message)).toContain(
@@ -654,7 +586,6 @@ it("validates evidence context ownership and references", () => {
(left, right) => left.context_id.localeCompare(right.context_id),
),
});
expect(orphanIssues.success).toBe(false);
if (orphanIssues.success)
throw new Error("Expected orphan context rejection");
expect(orphanIssues.error.issues.map(({ message }) => message)).toContain(
@@ -683,7 +614,6 @@ it("validates evidence context ownership and references", () => {
...facts.slice(1),
],
});
expect(dangling.success, fact).toBe(false);
if (dangling.success)
throw new Error(`Expected dangling ${fact} reference`);
expect(
@@ -711,7 +641,6 @@ it("validates evidence context ownership and references", () => {
...graph.nodes.slice(1),
],
});
expect(impossibleEvidence.success).toBe(false);
if (impossibleEvidence.success)
throw new Error("Expected incompatible evidence context and location");
expect(
@@ -739,10 +668,47 @@ it("shares provenance contexts while preserving fact-specific locations and unkn
},
evidenceContexts,
);
expect(second.evidence.context_id).toBe(first.evidence.context_id);
expect(second.evidence.location).not.toEqual(first.evidence.location);
const { graph_id: _graphId, ...semantic } = graph;
const combined = createJavaScriptSemanticGraph({
...semantic,
unknowns: [...graph.unknowns, second],
evidence_contexts: evidenceContexts.contexts,
coverage: {
...graph.coverage,
families: graph.coverage.families.map((family) =>
family.unknown_ids.includes(first.unknown_id)
? {
...family,
unknown_ids: [...family.unknown_ids, second.unknown_id],
}
: family,
),
},
});
const stored = javaScriptSemanticGraphSchema.parse(
JSON.parse(JSON.stringify(combined)),
);
expect(stored.evidence_contexts).toEqual(graph.evidence_contexts);
expect(second.unknown_id).not.toBe(first.unknown_id);
expect(evidenceContexts.contexts).toEqual(graph.evidence_contexts);
expect(stored.unknowns).toEqual(
expect.arrayContaining([
expect.objectContaining({
unknown_id: first.unknown_id,
evidence: first.evidence,
}),
expect.objectContaining({
unknown_id: second.unknown_id,
evidence: {
context_id: first.evidence.context_id,
location: {
available: false,
reason: "unresolved",
detail: "Another source location remains unresolved.",
},
},
}),
]),
);
});
const complete = <Value>(steps: Iterator<void, Value>): Value => {
@@ -772,12 +738,13 @@ it("preserves a transferred graph independent of the caller retained copy", () =
input.coverage.families.length = 0;
const graph = complete(steps);
expect(graph).toEqual(expected);
const nodeIds = graph.nodes.map(({ node_id }) => node_id);
expect(nodeIds).toEqual(nodeIds.toSorted());
expect(
javaScriptSemanticGraphSchema.parse(JSON.parse(JSON.stringify(graph))),
).toEqual(expected);
expect(isValidatedImmutableJavaScriptSemanticGraph(graph)).toBe(true);
expect(isValidatedImmutableJavaScriptSemanticGraph(expected)).toBe(false);
expect(Object.isFrozen(nested)).toBe(false);
});
const invalidGraphCases: {
@@ -880,22 +847,17 @@ it.each(invalidGraphCases)(
},
);
it("interns each distinct evidence context once under its content digest", () => {
it("interns valid normalized evidence after rejecting malformed provenance", () => {
const registry = new JavaScriptSemanticEvidenceContextRegistry();
const elsewhere: ApplicationGraphEvidence = {
...semanticGraphTestEvidence(),
location: {
available: true,
value: {
kind: "source-range",
source: "other.js",
start: { line: 7, column: 2 },
end: { line: 7, column: 9 },
},
},
};
const first = registry.intern(semanticGraphTestEvidence());
const repeated = registry.intern(elsewhere);
const observed = semanticGraphTestEvidence();
expect(() =>
registry.intern({
...observed,
extractor: { ...observed.extractor, name: "" },
}),
).toThrow(z.ZodError);
const first = registry.intern(observed);
const reordered = registry.intern({
...semanticGraphTestEvidence("inferred"),
limitations: [
@@ -904,10 +866,8 @@ it("interns each distinct evidence context once under its content digest", () =>
],
});
const inferred = registry.intern(semanticGraphTestEvidence("inferred"));
const { location: _location, ...context } = semanticGraphTestEvidence();
const { location: _location, ...context } = observed;
expect(repeated.context_id).toBe(first.context_id);
expect(repeated.location).toEqual(elsewhere.location);
expect(reordered.context_id).toBe(inferred.context_id);
expect(inferred.context_id).not.toBe(first.context_id);
expect(first.context_id).toBe(
@@ -916,19 +876,7 @@ it("interns each distinct evidence context once under its content digest", () =>
expect(registry.contexts.map(({ context_id }) => context_id)).toEqual(
[first.context_id, inferred.context_id].toSorted(),
);
expect(registry.resolve(repeated)).toEqual(elsewhere);
});
it("rejects invalid provenance in direct registry.intern calls before sealing", () => {
const registry = new JavaScriptSemanticEvidenceContextRegistry();
const baseEvidence = semanticGraphTestEvidence();
expect(() =>
registry.intern({
...baseEvidence,
extractor: { ...baseEvidence.extractor, name: "" },
}),
).toThrow(z.ZodError);
expect(registry.ownedContexts).toEqual([]);
expect(registry.resolve(first)).toEqual(observed);
});
it("seals owned builder records while still rejecting tampered spread copies", () => {
@@ -115,23 +115,6 @@ const registryForGraph = (
return registry;
};
it("returns every relevant unknown inline", () => {
const graph = semanticFixtureGraph(true);
const callable = graph.nodes.find(({ kind }) => kind === "function");
if (callable === undefined) throw new Error("Expected callable node");
const result = queryJavaScriptSemanticGraph(
graph,
javaScriptSemanticQueryInputSchema.parse({
seed: { kind: "semantic-node", node_id: callable.node_id },
direction: "forward-influence",
}),
);
expect(result).toMatchObject({
summary: { relevant_unknowns: 1 },
});
expect(result.unknowns).toHaveLength(1);
});
it("does not admit a semantic-node seed absent from the graph", () => {
const result = queryJavaScriptSemanticGraph(
semanticFixtureGraph(),
@@ -149,102 +132,67 @@ it("does not admit a semantic-node seed absent from the graph", () => {
});
});
it("returns the complete deterministic forward influence result inline", () => {
const graph = semanticFixtureGraph();
const input = {
seed: { kind: "literal" as const, value: "TOKEN" },
direction: "forward-influence" as const,
expected: { role: "sink" as const, classes: ["request" as const] },
};
const first = queryJavaScriptSemanticGraph(
graph,
javaScriptSemanticQueryInputSchema.parse(input),
);
expect(first).toMatchObject({
status: "found",
summary: { traversed_nodes: 4, traversed_relations: 3 },
relations: expect.any(Array),
});
expect(first.expected_match_node_ids).toHaveLength(1);
expect(first.relations).toHaveLength(3);
});
it("returns only the referenced evidence contexts with resolvable trace facts", () => {
const graph = semanticFixtureGraph();
const result = queryJavaScriptSemanticGraph(
graph,
javaScriptSemanticQueryInputSchema.parse({
seed: { kind: "literal", value: "TOKEN" },
direction: "forward-influence",
}),
);
const expectedContextIds = [
...new Set([
...result.nodes.map(({ evidence }) => evidence.context_id),
...result.relations.map(({ evidence }) => evidence.context_id),
...result.unknowns.map(({ evidence }) => evidence.context_id),
]),
].sort();
expect(result.evidence_contexts.map(({ context_id }) => context_id)).toEqual(
expectedContextIds,
);
for (const node of result.nodes)
expect(resolveJavaScriptSemanticEvidence(result, node.evidence)).toEqual(
resolveJavaScriptSemanticEvidence(graph, node.evidence),
);
});
it("traverses a path of 70 relations", () => {
it("returns reachable influence facts and only their evidence contexts", () => {
const original = semanticFixtureGraph();
const input = constructionInput(original);
const evidenceContexts = registryForGraph(original);
const request = original.nodes.find(({ kind }) => kind === "request");
if (request === undefined) throw new TypeError("Missing request node");
const chain = Array.from({ length: 70 }, (_, index) =>
node("binding", `long-chain-${index}`, evidenceContexts),
);
const chainRelations = chain.map((target, index) =>
createJavaScriptSemanticGraphRelation(
{
source_node_id: chain[index - 1]?.node_id ?? request.node_id,
target_node_id: target.node_id,
relation: "reads",
resolution: "resolved",
properties: {},
evidence: semanticGraphTestEvidence("inferred"),
const moduleNode = original.nodes.find(({ kind }) => kind === "module");
if (moduleNode === undefined)
throw new Error("Expected the unreachable module");
const { node_id: _moduleId, evidence, ...moduleInput } = moduleNode;
const moduleEvidence = resolveJavaScriptSemanticEvidence(original, evidence);
const unrelated = createJavaScriptSemanticGraphNode(
{
...moduleInput,
evidence: {
...moduleEvidence,
extractor: { ...moduleEvidence.extractor, name: "unreachable-module" },
},
evidenceContexts,
),
},
evidenceContexts,
);
const graph = createJavaScriptSemanticGraph({
...input,
...constructionInput(original),
nodes: original.nodes.map((entry) =>
entry.node_id === moduleNode.node_id ? unrelated : entry,
),
evidence_contexts: evidenceContexts.contexts,
nodes: [...input.nodes, ...chain],
relations: [...input.relations, ...chainRelations],
coverage: {
...original.coverage,
families: original.coverage.families.map((family) =>
family.family === "data-flow"
? {
...family,
retained_relations:
family.retained_relations + chainRelations.length,
}
: family,
),
},
});
const result = queryJavaScriptSemanticGraph(
graph,
javaScriptSemanticQueryInputSchema.parse({
seed: { kind: "literal", value: "TOKEN" },
direction: "forward-influence",
expected: { role: "sink", classes: ["request"] },
}),
);
expect(result.summary.traversed_nodes).toBe(74);
expect(result.nodes).toHaveLength(74);
expect(result).toMatchObject({
status: "found",
summary: { traversed_nodes: 4, traversed_relations: 3 },
});
expect(result.nodes.map(({ kind }) => kind).sort()).toEqual([
"binding",
"function",
"literal",
"request",
]);
expect(result.relations.map(({ relation }) => relation).sort()).toEqual([
"captures",
"constructs-request",
"defines",
]);
expect(result.expected_match_node_ids).toEqual([
original.nodes.find(({ kind }) => kind === "request")?.node_id,
]);
expect(result.evidence_contexts).toEqual(
graph.evidence_contexts.filter(
({ context_id }) => context_id !== unrelated.evidence.context_id,
),
);
for (const fact of [...result.nodes, ...result.relations])
expect(resolveJavaScriptSemanticEvidence(result, fact.evidence)).toEqual(
resolveJavaScriptSemanticEvidence(graph, fact.evidence),
);
});
it("accepts deeply nested semantic properties", () => {
@@ -263,8 +211,9 @@ it("accepts deeply nested semantic properties", () => {
});
it("keeps relevant dynamic frontiers unknown", () => {
const graph = semanticFixtureGraph(true);
const result = queryJavaScriptSemanticGraph(
semanticFixtureGraph(true),
graph,
javaScriptSemanticQueryInputSchema.parse({
seed: { kind: "literal", value: "TOKEN" },
direction: "forward-influence",
@@ -272,12 +221,11 @@ it("keeps relevant dynamic frontiers unknown", () => {
);
expect(result.status).toBe("partial");
expect(result.coverage.status).toBe("partial");
expect(result.unknowns).toMatchObject([
{ reason: "dynamic-call", relation_kinds: ["calls"] },
]);
expect(result.summary.relevant_unknowns).toBe(1);
expect(result.unknowns).toEqual(graph.unknowns);
});
it("reports partial status when retained graph facts were truncated", () => {
it("reports a partial trace when the graph has unknown omission counts", () => {
const graph = semanticFixtureGraph();
const partial = createJavaScriptSemanticGraph({
...constructionInput(graph),
@@ -291,6 +239,12 @@ it("reports partial status when retained graph facts were truncated", () => {
},
limitations: ["The node ceiling left omission extents unknown."],
});
expect(partial.coverage).toMatchObject({
status: "partial",
truncated: true,
omitted_nodes: null,
omitted_relations: null,
});
const result = queryJavaScriptSemanticGraph(
partial,
javaScriptSemanticQueryInputSchema.parse({
@@ -594,7 +548,14 @@ it("keeps candidate uncertainty at the end of a long reachable path", () => {
expect(result).toMatchObject({
status: "ambiguous",
coverage: { status: "partial" },
summary: {
traversed_nodes: include ? 72 : 71,
traversed_relations: include ? 71 : 70,
},
});
expect(result.nodes).toHaveLength(include ? 72 : 71);
const reachable = include ? chain : chain.slice(0, -1);
expect(result.nodes.map(({ node_id }) => node_id).toSorted()).toEqual(
reachable.map(({ node_id }) => node_id).toSorted(),
);
}
});
@@ -14,7 +14,7 @@ cliTest(
const root = await createTestTempDirectory("rea-graph-query-coverage-");
await writeFile(
join(root, "main.cjs"),
'const { EventEmitter } = require("node:events"); const bus = new EventEmitter(); bus.on("", function emptyListener() {}); function read() { return this.speed; }',
'const { EventEmitter } = require("node:events"); const bus = new EventEmitter(); bus.on("", function emptyListener() {}); bus.on("data", function dataListener() {}); function read() { return this.speed; }',
);
await writeFile(join(root, "other.js"), "export const answer = 42;");
const response = await cli.run({
@@ -75,6 +75,14 @@ cliTest(
}),
]),
);
expect(
seedNodes
.map((node) => [node?.kind, node?.properties.event_name])
.sort(),
).toEqual([
["event", ""],
["listener", ""],
]);
} else {
expect(trace.summary.relevant_unknowns).toBeGreaterThan(0);
expect(seedNodes).toContainEqual(
@@ -17,9 +17,9 @@ cliTest(
clearTimeout(handle);
}
function latest() {
let handle = setTimeout(work, 20);
handle = setTimeout(work, 30);
clearTimeout(handle);
let handle = setInterval(work, 20);
handle = setInterval(work, 30);
clearInterval(handle);
}
function conditional() {
let handle = setTimeout(work, 40);
@@ -31,7 +31,6 @@ cliTest(
const result = await analyzeJavaScriptDirectory("CLI", cli, root);
expect(result.statistics.parse_failures).toBe(0);
const graph = result.semantic_graph;
expect(graph).not.toBeNull();
if (graph === null) throw new Error("Expected a semantic graph");
const cancellationTargets = graph.relations
.filter(({ relation }) => relation === "cancels-timer")
@@ -39,14 +38,22 @@ cliTest(
resolution,
delay: graph.nodes.find(({ node_id }) => node_id === target_node_id)
?.properties.delay_milliseconds,
}));
expect(cancellationTargets).toEqual(
expect.arrayContaining([
{ resolution: "resolved", delay: 30 },
{ resolution: "candidate", delay: 40 },
]),
);
expect(cancellationTargets).toHaveLength(2);
}))
.sort((left, right) => Number(left.delay) - Number(right.delay));
expect(cancellationTargets).toEqual([
{ resolution: "resolved", delay: 30 },
{ resolution: "candidate", delay: 40 },
]);
const scheduled = graph.relations
.filter(({ relation }) => relation === "schedules-timer")
.map(
({ target_node_id }) =>
graph.nodes.find(({ node_id }) => node_id === target_node_id)
?.properties.delay_milliseconds,
);
expect(scheduled.map(Number).sort((left, right) => left - right)).toEqual([
10, 20, 30, 40,
]);
expect(
graph.unknowns.filter(({ family }) => family === "timer"),
).toHaveLength(2);
@@ -45,9 +45,6 @@ it("uses the first structured observation when paths repeat", async () => {
const sourceMapObservation = analysis.source_maps.find(
({ path }) => path === "app.js.map",
);
expect(packageObservation).toBeDefined();
expect(jsonObservation).toBeDefined();
expect(sourceMapObservation).toBeDefined();
if (
packageObservation === undefined ||
jsonObservation === undefined ||
@@ -126,129 +123,53 @@ it("uses the first structured observation when paths repeat", async () => {
}
});
it("preserves unknown omitted-key count for unavailable JSON", async () => {
const root = await createTestTempDirectory("rea-unavailable-json-");
it("distinguishes unavailable and unselected JSON while preserving unknown key counts", async () => {
const root = await createTestTempDirectory("rea-json-observation-coverage-");
const unavailable = "unavailable.json";
const unselected = ["unselected.json", "upper.JSON"];
await Promise.all([
writeFile(join(root, "package.json"), JSON.stringify({ name: "fixture" })),
writeFile(join(root, "config.json"), Buffer.from([0xff])),
writeFile(join(root, unavailable), Buffer.from([0xff])),
...unselected.map((path) =>
writeFile(join(root, path), JSON.stringify({ setting: true })),
),
]);
const snapshot = await scanCanonicalArtifactInventory(root, {});
const reader = createJavaScriptArtifactReader(root, "directory");
try {
const files = await readJavaScriptArtifactFiles(reader, snapshot);
const files = await readJavaScriptArtifactFiles(
reader,
snapshot,
undefined,
["package.json", unavailable],
);
const { analysis } = await analyzeArtifactFiles(files);
const graph = await immutableArtifactGraph(snapshot, files, analysis);
const configFile = graph.nodes.find(({ observations }) =>
observations.some(
const observations = graph.nodes.flatMap(
({ observations }) => observations,
);
expect(
observations.find(
({ properties }) =>
properties.path === "config.json" && properties.file_kind === "json",
),
);
const configObservation = configFile?.observations.find(
({ properties }) =>
properties.path === "config.json" && properties.file_kind === "json",
);
expect(configObservation?.properties).toMatchObject({
path: "config.json",
properties.path === unavailable && properties.file_kind === "json",
)?.properties,
).toMatchObject({
text_status: "invalid-utf8",
json_parse_status: "unavailable",
omitted_json_top_level_keys: null,
});
} finally {
await reader.close();
}
});
it("preserves unknown omitted-key count for unselected JSON", async () => {
const root = await createTestTempDirectory("rea-unselected-json-");
await Promise.all([
writeFile(join(root, "package.json"), JSON.stringify({ name: "fixture" })),
writeFile(join(root, "config.json"), JSON.stringify({ setting: true })),
]);
const snapshot = await scanCanonicalArtifactInventory(root, {});
const reader = createJavaScriptArtifactReader(root, "directory");
try {
const files = await readJavaScriptArtifactFiles(
reader,
snapshot,
undefined,
["package.json"],
);
const { analysis } = await analyzeArtifactFiles(files);
const graph = await immutableArtifactGraph(snapshot, files, analysis);
const configFile = graph.nodes.find(({ observations }) =>
observations.some(
({ properties }) =>
properties.path === "config.json" && properties.file_kind === "json",
),
);
const configObservation = configFile?.observations.find(
({ properties }) =>
properties.path === "config.json" && properties.file_kind === "json",
);
expect(configObservation?.properties).toMatchObject({
path: "config.json",
text_status: "outside-analysis-scope",
json_parse_status: null,
omitted_json_top_level_keys: null,
});
} finally {
await reader.close();
}
});
it("preserves unknown omitted-key count for unselected uppercase JSON", async () => {
const root = await createTestTempDirectory("rea-unselected-uppercase-json-");
await Promise.all([
writeFile(join(root, "package.json"), JSON.stringify({ name: "fixture" })),
writeFile(join(root, "config.JSON"), JSON.stringify({ setting: true })),
]);
const snapshot = await scanCanonicalArtifactInventory(root, {});
const reader = createJavaScriptArtifactReader(root, "directory");
try {
const files = await readJavaScriptArtifactFiles(
reader,
snapshot,
undefined,
["package.json"],
);
const { analysis } = await analyzeArtifactFiles(files);
const graph = await immutableArtifactGraph(snapshot, files, analysis);
const configFile = graph.nodes.find(({ observations }) =>
observations.some(
({ properties }) =>
properties.path === "config.JSON" && properties.file_kind === "json",
),
);
const configObservation = configFile?.observations.find(
({ properties }) =>
properties.path === "config.JSON" && properties.file_kind === "json",
);
expect(configObservation?.properties).toMatchObject({
path: "config.JSON",
text_status: "outside-analysis-scope",
json_parse_status: null,
omitted_json_top_level_keys: null,
});
for (const path of unselected)
expect(
observations.find(
({ properties }) =>
properties.path === path && properties.file_kind === "json",
)?.properties,
).toMatchObject({
text_status: "outside-analysis-scope",
json_parse_status: null,
omitted_json_top_level_keys: null,
});
} finally {
await reader.close();
}