mirror of
https://github.com/morluto/rea.git
synced 2026-11-15 19:23:24 +00:00
365 lines
13 KiB
TypeScript
365 lines
13 KiB
TypeScript
import { expect, it } from "vitest";
|
|
import { graphForJavaScript } from "../../../tests/fixtures/javascriptSemanticGraph.js";
|
|
import { queryJavaScriptSemanticGraph } from "../../domain/javascript/javascriptSemanticQuery.js";
|
|
import { resolveJavaScriptSemanticQuerySeeds } from "../../domain/javascript/javascriptSemanticQueryIdentity.js";
|
|
import { javaScriptSemanticQueryInputSchema } from "../../domain/javascript/javascriptSemanticQuerySchemas.js";
|
|
import { parseJavaScriptSource } from "../../domain/javascript/javascriptSourceParser.js";
|
|
import { analyzeParsedJavaScriptSemanticsSteps } from "../../domain/javascript/javascriptSemanticAnalysis.js";
|
|
import { completeSemanticSteps } from "../../domain/javascript/javascriptSemanticTraversal.js";
|
|
|
|
const trace = (body: string) => {
|
|
const graph = graphForJavaScript(
|
|
`const base = "https://example.test"; ${body}`,
|
|
);
|
|
return queryJavaScriptSemanticGraph(
|
|
graph,
|
|
javaScriptSemanticQueryInputSchema.parse({
|
|
seed: { kind: "literal", value: "https://example.test" },
|
|
direction: "forward-influence",
|
|
}),
|
|
);
|
|
};
|
|
|
|
it.each([
|
|
["declaration", 'const url = base + "/x"; fetch(url);'],
|
|
["assignment", 'let url; url = base + "/x"; fetch(url);'],
|
|
["nested operator", 'const url = (base + "/x") + "/y"; fetch(url);'],
|
|
["call argument", 'fetch(base + "/x");'],
|
|
["template", "fetch(`${base}/x`);"],
|
|
])("follows transformed input to a %s without opt-in", (_name, body) => {
|
|
const result = trace(body);
|
|
expect(result.nodes.map((node) => node.label)).toContain("argument 0");
|
|
expect(result.relations.some((edge) => edge.relation === "influences")).toBe(
|
|
true,
|
|
);
|
|
});
|
|
|
|
it("explains an unmodeled dynamic call result at the reached argument", () => {
|
|
const result = trace('const url = wrap(base + "/x"); fetch(url);');
|
|
expect(result.unknowns).toContainEqual(
|
|
expect.objectContaining({
|
|
reason: "dynamic-call",
|
|
family: "data-flow",
|
|
relation_kinds: ["influences"],
|
|
}),
|
|
);
|
|
});
|
|
|
|
it.each([
|
|
'const obj = { url: wrap(base + "/x") }; fetch(obj.url);',
|
|
'function address() { return wrap(base + "/x"); }',
|
|
'consume(wrap(base + "/x"));',
|
|
])("keeps nested dynamic call return influence unknown: %s", (body) => {
|
|
const result = trace(body);
|
|
expect(result.status).not.toBe("found");
|
|
expect(result.unknowns).toContainEqual(
|
|
expect.objectContaining({
|
|
reason: "dynamic-call",
|
|
family: "data-flow",
|
|
relation_kinds: ["influences"],
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("does not report an unused dynamic call result as a missing value", () => {
|
|
const result = trace('consume(base + "/x");');
|
|
expect(result.unknowns).not.toContainEqual(
|
|
expect.objectContaining({
|
|
reason: "dynamic-call",
|
|
family: "data-flow",
|
|
relation_kinds: ["influences"],
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("bounds operator production before graph admission and reports truncation", () => {
|
|
const expressions = Array.from({ length: 500 }, () => "${base}").join("");
|
|
const source = `const base = "value"; const value = \`${expressions}\`;`;
|
|
const parsed = parseJavaScriptSource(source, "app.js");
|
|
if (parsed === null) throw new Error("Expected parsed source");
|
|
const ir = completeSemanticSteps(
|
|
analyzeParsedJavaScriptSemanticsSteps(parsed, "import", 4),
|
|
);
|
|
expect(ir.expressionFlowsTruncated).toBe(true);
|
|
expect(ir.expressionFlows.length).toBeLessThanOrEqual(4);
|
|
expect(
|
|
ir.expressionFlows.reduce((count, flow) => count + flow.operands.length, 0),
|
|
).toBeLessThanOrEqual(4);
|
|
expect(ir.coverage).toMatchObject({ status: "partial", omittedCount: null });
|
|
expect(graphForJavaScript(source, ir).coverage.truncated).toBe(true);
|
|
});
|
|
|
|
it("follows a transformed return expression", () => {
|
|
const result = trace('function address() { return base + "/x"; }');
|
|
expect(result.nodes.map((node) => node.label)).toContain("return");
|
|
});
|
|
|
|
it("does not treat a deferred callback body as an enclosing call argument value", () => {
|
|
const graph = graphForJavaScript(
|
|
'const base = "https://example.test"; consume(() => base + "/x");',
|
|
);
|
|
const base = graph.nodes.find(
|
|
(node) => node.kind === "binding" && node.label === "base",
|
|
);
|
|
const argument = graph.nodes.find(
|
|
(node) => node.kind === "expression" && node.label === "argument 0",
|
|
);
|
|
expect(base).toBeDefined();
|
|
expect(argument).toBeDefined();
|
|
const result = queryJavaScriptSemanticGraph(
|
|
graph,
|
|
javaScriptSemanticQueryInputSchema.parse({
|
|
seed: { kind: "literal", value: "https://example.test" },
|
|
direction: "forward-influence",
|
|
include_ambiguous_dynamic_edges: true,
|
|
}),
|
|
);
|
|
expect(result.nodes.map((node) => node.node_id)).not.toContain(
|
|
argument?.node_id,
|
|
);
|
|
});
|
|
|
|
it.each(['"/unique"', "`/unique`"])(
|
|
"seeds an exact literal operand %s and reaches the receiving argument",
|
|
(operand) => {
|
|
const graph = graphForJavaScript(
|
|
`const prefix = "root"; const path = prefix + ${operand}; fetch(path);`,
|
|
);
|
|
const result = queryJavaScriptSemanticGraph(
|
|
graph,
|
|
javaScriptSemanticQueryInputSchema.parse({
|
|
seed: { kind: "literal", value: "/unique" },
|
|
direction: "forward-influence",
|
|
}),
|
|
);
|
|
expect(result.nodes.map((node) => node.label)).toContain("argument 0");
|
|
},
|
|
);
|
|
|
|
it("marks a short-circuited operand as conditional without claiming alias identity", () => {
|
|
const graph = graphForJavaScript(
|
|
'const base = "unique"; const maybe = ready && base; fetch(maybe);',
|
|
);
|
|
const conditional = graph.relations.filter(
|
|
(edge) =>
|
|
edge.relation === "influences" && edge.properties.conditional === true,
|
|
);
|
|
expect(conditional).toHaveLength(1);
|
|
expect(
|
|
graph.nodes.find((node) => node.node_id === conditional[0]?.source_node_id)
|
|
?.label,
|
|
).toBe("base");
|
|
});
|
|
|
|
it("reports uncertainty on a read inside an unsupported operand", () => {
|
|
const result = trace('const url = format(base) + "/x"; fetch(url);');
|
|
expect(result.status).toBe("partial");
|
|
expect(
|
|
result.unknowns.some((unknown) =>
|
|
unknown.detail.includes("unmodeled operator operand"),
|
|
),
|
|
).toBe(true);
|
|
});
|
|
|
|
it.each([
|
|
'function answer() { return "return-only"; }',
|
|
'const answer = () => "return-only";',
|
|
])("seeds a literal returned directly: %s", (source) => {
|
|
const graph = graphForJavaScript(source);
|
|
const result = queryJavaScriptSemanticGraph(
|
|
graph,
|
|
javaScriptSemanticQueryInputSchema.parse({
|
|
seed: { kind: "literal", value: "return-only" },
|
|
direction: "forward-influence",
|
|
}),
|
|
);
|
|
expect(result.summary.total_seed_matches).toBeGreaterThan(0);
|
|
expect(result.nodes.map((node) => node.label)).toContain("return");
|
|
});
|
|
|
|
it("marks a logical assignment's transformed input conditional", () => {
|
|
const graph = graphForJavaScript(
|
|
'const base = "unique"; let value; value ||= base + "/x";',
|
|
);
|
|
const conditional = graph.relations.find(
|
|
(edge) =>
|
|
edge.relation === "influences" &&
|
|
edge.properties.conditional === true &&
|
|
graph.nodes.find((node) => node.node_id === edge.target_node_id)
|
|
?.label === "value",
|
|
);
|
|
expect(conditional).toBeDefined();
|
|
});
|
|
|
|
it("keeps sequence side effects unknown instead of attributing earlier values directly", () => {
|
|
const result = trace('const url = (touch(base), "fixed"); fetch(url);');
|
|
expect(result.status).toBe("partial");
|
|
expect(
|
|
result.unknowns.some((unknown) =>
|
|
unknown.detail.includes("unmodeled operator operand"),
|
|
),
|
|
).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 = {
|
|
...graph,
|
|
nodes: graph.nodes.filter(
|
|
(node) =>
|
|
node.properties.literal_argument_call_site_node_id === undefined,
|
|
),
|
|
};
|
|
const seeds = resolveJavaScriptSemanticQuerySeeds(
|
|
legacy,
|
|
javaScriptSemanticQueryInputSchema.parse({
|
|
seed: { kind: "literal", value: "only-direct" },
|
|
direction: "forward-influence",
|
|
}),
|
|
);
|
|
const call = graph.nodes.find((node) => node.kind === "call-site");
|
|
expect(seeds).toEqual([call?.node_id]);
|
|
});
|
|
|
|
it("does not treat literals inside a spread or deferred callback as direct arguments", () => {
|
|
const graph = graphForJavaScript(
|
|
'consume(...["spread-only"], () => "deferred-only");',
|
|
);
|
|
for (const value of ["spread-only", "deferred-only"]) {
|
|
const result = queryJavaScriptSemanticGraph(
|
|
graph,
|
|
javaScriptSemanticQueryInputSchema.parse({
|
|
seed: { kind: "literal", value },
|
|
direction: "forward-influence",
|
|
}),
|
|
);
|
|
expect(
|
|
result.nodes.filter(
|
|
(node) =>
|
|
node.properties.literal_argument_call_site_node_id !== undefined,
|
|
),
|
|
).toEqual([]);
|
|
}
|
|
});
|
|
|
|
it.each([
|
|
'const obj = { url: base + "/x" }; fetch(obj.url);',
|
|
'const values = [base + "/x"]; fetch(values[0]);',
|
|
'const url = wrap(base + "/x"); fetch(url);',
|
|
])("reports unknown when a consumer boundary is unmodeled: %s", (body) => {
|
|
const result = trace(body);
|
|
expect(result.status).not.toBe("found");
|
|
expect(result.unknowns.length).toBeGreaterThan(0);
|
|
});
|
|
|
|
it("does not reuse an outer literal for the same text in a nested function", () => {
|
|
const graph = graphForJavaScript(
|
|
'const suffix = "end"; const value = true ? "token" : () => "token" + suffix;',
|
|
);
|
|
const tokens = graph.nodes.filter(
|
|
(node) => node.kind === "literal" && node.properties.value === "token",
|
|
);
|
|
expect(tokens.length).toBeGreaterThan(1);
|
|
const inner = tokens.find((node) => node.function_node_id !== null);
|
|
const outer = tokens.find((node) => node.function_node_id === null);
|
|
if (inner === undefined || outer === undefined)
|
|
throw new Error("Expected separate outer and nested token literals");
|
|
expect(inner.identity.source_range).not.toEqual(outer.identity.source_range);
|
|
const traced = queryJavaScriptSemanticGraph(
|
|
graph,
|
|
javaScriptSemanticQueryInputSchema.parse({
|
|
seed: { kind: "semantic-node", node_id: outer.node_id },
|
|
direction: "forward-influence",
|
|
}),
|
|
);
|
|
expect(traced.nodes.map((node) => node.node_id)).not.toContain(inner.node_id);
|
|
});
|
|
|
|
it("does not send an ignored literal argument to the call result", () => {
|
|
const graph = graphForJavaScript(
|
|
'function ignore(x) { return "safe"; } const result = ignore("token");',
|
|
);
|
|
const resultBinding = graph.nodes.find(
|
|
(node) => node.kind === "binding" && node.label === "result",
|
|
);
|
|
if (resultBinding === undefined) throw new Error("Expected result binding");
|
|
const forward = queryJavaScriptSemanticGraph(
|
|
graph,
|
|
javaScriptSemanticQueryInputSchema.parse({
|
|
seed: { kind: "literal", value: "token" },
|
|
direction: "forward-influence",
|
|
}),
|
|
);
|
|
expect(forward.nodes.some((node) => node.kind === "call-site")).toBe(true);
|
|
expect(forward.nodes.map((node) => node.node_id)).not.toContain(
|
|
resultBinding.node_id,
|
|
);
|
|
const backward = queryJavaScriptSemanticGraph(
|
|
graph,
|
|
javaScriptSemanticQueryInputSchema.parse({
|
|
seed: { kind: "semantic-node", node_id: resultBinding.node_id },
|
|
direction: "backward-provenance",
|
|
}),
|
|
);
|
|
expect(
|
|
backward.nodes.some(
|
|
(node) =>
|
|
node.properties.value === "token" ||
|
|
node.properties.literal_argument_value === "token",
|
|
),
|
|
).toBe(false);
|
|
expect(backward.nodes.some((node) => node.properties.value === "safe")).toBe(
|
|
true,
|
|
);
|
|
});
|
|
|
|
it("keeps conditional binding candidates distinct from operand occurrences", () => {
|
|
const graph = graphForJavaScript('export const choice = flag ? 1 : "1";');
|
|
const choices = graph.nodes.filter(
|
|
(node) =>
|
|
node.kind === "literal" &&
|
|
(node.properties.value === 1 || node.properties.value === "1"),
|
|
);
|
|
expect(choices).toHaveLength(4);
|
|
expect(
|
|
new Set(
|
|
choices.map((node) =>
|
|
JSON.stringify([node.properties.value, node.identity.source_range]),
|
|
),
|
|
).size,
|
|
).toBe(4);
|
|
});
|
|
|
|
it("projects repeated operator literals with indexed lookup", () => {
|
|
const count = 1_200;
|
|
const declarations = Array.from(
|
|
{ length: count },
|
|
(_, index) => `const item${String(index)} = input + "/item";`,
|
|
);
|
|
const graph = graphForJavaScript(
|
|
`const input = "root";\n${declarations.join("\n")}`,
|
|
);
|
|
expect(
|
|
graph.nodes.filter(
|
|
(node) => node.kind === "literal" && node.properties.value === "/item",
|
|
),
|
|
).toHaveLength(count);
|
|
});
|