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"]);
});