Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.
C aiderastclaude-codecode-analysiscode-intelligencecodexcursorcypherdeveloper-toolsgemini-cligraph-visualizationkilocodeknowledge-graphmcpmcp-servermodel-context-protocolopencodesqlitetree-sitterwindsurf
// @vitest-environment jsdom
/*
* Der Fokus in beide Richtungen, ohne einen einzigen gerenderten Pixel.
*
* Das Panel wird hier ausdruecklich unsichtbar gefahren (`visible={false}`).
* Das ist kein Trick, um die Szene loszuwerden, sondern genau die Lage, die
* das Panel auch im Betrieb hat, solange niemand es aufgeklappt hat: geladen
* wird trotzdem, und der Fokus folgt trotzdem, damit die Kamera schon dort
* steht, wo sie hingehoert, wenn jemand aufklappt. Was dabei ungeprueft
* bleibt, ist das Bild selbst, und das prueft der Beweislauf im Browser mit
* einem echten WebGL-Kontext (tools/smoke-w3.mjs).
*/
import { act } from 'react';
import { createRoot, type Root } from 'react-dom/client';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import GalaxyPanel from './GalaxyPanel';
import type { GalaxyPanelProps } from './GalaxyPanel';
import { GALAXY_LEGEND_KEY } from './galaxy-legend';
import { HIERARCHY_COLUMN_WIDTH, HIERARCHY_LANE_SPACING } from './hierarchy-layout';
import { toEditorRange } from '../core/positions';
import type { SymbolRef } from '../core/focus-protocol';
import type { ClosureResult } from '../provider/closure';
let container: HTMLDivElement;
let root: Root;
const LAYOUT = {
nodes: [
{
id: 51, x: -244, y: -453, z: -46, label: 'Function', name: 'createUser',
file_path: 'src/services/userService.ts',
qualified_name: 'atlas.src.services.userService.createUser',
start_line: 23, end_line: 36, size: 7.6, color: '#ffe080', in_calls: 2,
},
{
id: 69, x: -143, y: -599, z: -43, label: 'Function', name: 'validateUser',
file_path: 'src/util/validate.ts',
qualified_name: 'atlas.src.util.validate.validateUser',
start_line: 19, end_line: 31, size: 4, color: '#ffa060',
},
{
id: 74, x: 12, y: 8, z: 3, label: 'EnvVar', name: 'DB_URL',
qualified_name: '__env__DB_URL', size: 3, color: '#88aaff',
},
],
edges: [
{ source: 51, target: 69, type: 'CALLS' },
/*
* Eine Art, die die Farbtabelle NICHT kennt.
*
* Bis W9 stand hier CONFIGURES; seitdem hat dieser Typ eine eigene
* Farbe (die Engine dieses Projekts liefert ihn wirklich), und die
* Zusicherung "was die Tabelle nicht kennt, bekommt die Vorgabefarbe"
* braucht darum einen Namen, den sie auch morgen nicht kennt.
*/
{ source: 51, target: 74, type: 'WHAT_IS_THIS' },
],
total_nodes: 76,
};
const okFetch = () => vi.fn(async () => new Response(JSON.stringify(LAYOUT), { status: 200 }));
/**
* Ein `fetch` je Test, nicht je Render.
*
* Das ist keine Bequemlichkeit: das Panel laedt neu, wenn sich seine
* Ladequelle aendert, und ein frisches Mock bei jedem Render waere ein
* Neuladen bei jedem Render. Die Zaehler unten wuerden dann etwas messen, das
* es im Betrieb nicht gibt.
*/
let sharedFetch: ReturnType<typeof okFetch>;
beforeEach(() => {
(globalThis as unknown as Record<string, unknown>).IS_REACT_ACT_ENVIRONMENT = true;
container = document.createElement('div');
document.body.appendChild(container);
root = createRoot(container);
sharedFetch = okFetch();
});
afterEach(async () => {
await act(async () => {
root.unmount();
});
container.remove();
globalThis.__atlasGalaxy = undefined;
});
function props(overrides: Partial<GalaxyPanelProps> = {}): GalaxyPanelProps {
return {
project: 'atlas-sample',
visible: false,
onOpenNode: vi.fn(),
fetch: sharedFetch as unknown as typeof fetch,
...overrides,
};
}
async function render(next: GalaxyPanelProps): Promise<void> {
await act(async () => {
root.render(<GalaxyPanel {...next} />);
});
}
const seam = () => globalThis.__atlasGalaxy!;
const noteText = () =>
container.querySelector('[data-testid="atlas-galaxy-note"]')?.textContent ?? '';
const headlineText = () =>
container.querySelector('[data-testid="atlas-galaxy-headline"]')?.textContent ?? '';
/** Die zweite Zeile des Kopfes (W9): woraus die Linien bestehen, was fehlt. */
const edgeNoteText = () =>
container.querySelector('[data-testid="atlas-galaxy-edgenote"]')?.textContent ?? '';
describe('GalaxyPanel', () => {
it('laedt das Layout und sagt, was es geladen hat', async () => {
await render(props());
expect((sharedFetch.mock.calls[0] as unknown as [string])[0])
.toBe('/api/layout?project=atlas-sample&max_nodes=5000');
expect(container.querySelector('[data-testid="atlas-galaxy"]')).not.toBeNull();
expect(seam().nodes).toBe(3);
expect(headlineText()).toContain('3 nodes, 2 edges from /api/layout');
expect(headlineText()).toContain('76 nodes indexed');
});
it('zeigt einen Ladefehler, statt leer zu bleiben', async () => {
const failing = vi.fn(async () => new Response('{"error":"no such project"}', { status: 404 }));
await render(props({ fetch: failing as unknown as typeof fetch }));
expect(headlineText()).toContain('layout unavailable');
expect(headlineText()).toContain('404');
expect(seam().nodes).toBe(0);
});
it('fliegt das Twin-Subjekt an und hebt Knoten plus Nachbarn hervor', async () => {
await render(props());
expect(seam().targetChanges).toBe(0);
await render(props({ focusQualifiedName: 'atlas.src.services.userService.createUser' }));
expect(seam().targetChanges).toBe(1);
expect(seam().highlightedCount).toBe(3);
expect(seam().lastTargetQn).toBe('atlas.src.services.userService.createUser');
expect(noteText()).toBe('');
});
it('sagt ehrlich, wenn das Subjekt nicht im geladenen Layout liegt', async () => {
await render(props());
await render(props({
focusQualifiedName: 'atlas.src.nowhere.hidden',
focusName: 'hidden',
}));
expect(noteText()).toContain('hidden is not in the loaded layout');
expect(noteText()).toContain('5000 node budget');
expect(seam().targetChanges).toBe(0);
});
it('oeffnet einen angeklickten Knoten und fliegt ihn an', async () => {
const onOpenNode = vi.fn();
await render(props({ onOpenNode }));
let found = false;
await act(async () => {
found = seam().clickNode('atlas.src.util.validate.validateUser');
});
expect(found).toBe(true);
expect(onOpenNode).toHaveBeenCalledTimes(1);
expect(onOpenNode.mock.calls[0][0]).toMatchObject({
name: 'validateUser',
file_path: 'src/util/validate.ts',
});
expect(seam().targetChanges).toBe(1);
expect(seam().highlightedCount).toBe(2);
});
it('oeffnet nichts fuer einen Knoten ohne Datei und sagt, warum', async () => {
const onOpenNode = vi.fn();
await render(props({ onOpenNode }));
await act(async () => {
seam().clickNode('__env__DB_URL');
});
expect(onOpenNode).not.toHaveBeenCalled();
expect(noteText()).toContain('DB_URL');
expect(noteText()).toContain('nothing to open');
// Angeflogen wird er trotzdem: gezeigt wird er ja.
expect(seam().targetChanges).toBe(1);
});
it('meldet einen unbekannten Namen am Testgriff, statt still nichts zu tun', async () => {
await render(props());
let found = true;
await act(async () => {
found = seam().clickNode('gibt.es.nicht');
});
expect(found).toBe(false);
});
it('zaehlt jede Fahrt, auch die zweite auf dasselbe Symbol', async () => {
const focusQualifiedName = 'atlas.src.services.userService.createUser';
await render(props({ focusQualifiedName }));
expect(seam().targetChanges).toBe(1);
await act(async () => {
seam().clickNode(focusQualifiedName);
});
expect(seam().targetChanges).toBe(2);
});
});
describe('dedicated Galaxy selection', () => {
it('keeps source-backed selections in Galaxy until Open source is requested', async () => {
const onSelectNode = vi.fn();
const onOpenNode = vi.fn();
await render(props({ workspaceExpanded: true, onSelectNode, onOpenNode, selectedNode: LAYOUT.nodes[0] }));
await act(async () => { seam().clickNode('atlas.src.services.userService.createUser'); });
expect(onSelectNode).toHaveBeenCalledWith(expect.objectContaining({ id: 51 }));
expect(onOpenNode).not.toHaveBeenCalled();
const open = [...container.querySelectorAll('button')].find(button => button.textContent === 'Open source');
await act(async () => open!.click());
expect(onOpenNode).toHaveBeenCalledWith(LAYOUT.nodes[0]);
});
it('attaches graph-only selections without pretending they have a source file', async () => {
const onSelectNode = vi.fn();
const onOpenNode = vi.fn();
await render(props({ workspaceExpanded: true, onSelectNode, onOpenNode }));
await act(async () => { seam().clickNode('__env__DB_URL'); });
expect(onSelectNode).toHaveBeenCalledWith(expect.objectContaining({ id: 74, name: 'DB_URL' }));
expect(onOpenNode).not.toHaveBeenCalled();
});
it('offers node lookup and keeps collapse out of the dedicated workspace', async () => {
await render(props({ workspaceExpanded: true, onToggleVisible: vi.fn() }));
expect(container.querySelector('[aria-label="Find a graph node"]')).not.toBeNull();
expect(container.querySelector('[data-testid="atlas-galaxy-collapse"]')).toBeNull();
});
});
/*
* Die Legende unter dem Kopf (W4d).
*
* Der Speicher wird von aussen gesetzt, damit "der Zustand ueberlebt den
* Reload" ohne einen echten Reload pruefbar ist: neu gemountet mit demselben
* Speicher ist genau die Lage nach einem Reload, und der Beweislauf im Browser
* laedt danach zusaetzlich wirklich neu.
*/
function memoryStore(initial: Record<string, string> = {}): Storage {
const map = new Map(Object.entries(initial));
return {
get length() {
return map.size;
},
clear: () => map.clear(),
getItem: (key: string) => map.get(key) ?? null,
key: (index: number) => [...map.keys()][index] ?? null,
removeItem: (key: string) => {
map.delete(key);
},
setItem: (key: string, value: string) => {
map.set(key, value);
},
} as Storage;
}
const legendEntries = () =>
[...container.querySelectorAll('[data-testid="atlas-galaxy-legend-entry"]')];
const toggle = () =>
container.querySelector<HTMLButtonElement>('[data-testid="atlas-galaxy-legend-toggle"]');
/**
* Ein Speicher, in dem die Legende schon aufgeklappt ist.
*
* Seit W5c ist ZU die Vorgabe (das Panel ist schmal, und die aufgeklappte
* Legende nahm den Platz des Bildes, das sie erklaert). Wer den Inhalt der
* Legende pruefen will, klappt sie also erst auf, und das ist hier die
* gespeicherte Antwort eines Lesers, der das getan hat.
*/
const openStore = () => memoryStore({ [GALAXY_LEGEND_KEY]: 'open' });
describe('GalaxyPanel und die Legende', () => {
it('ist im schmalen Panel default zu, damit der Graph den Platz behaelt', async () => {
await render(props({ legendStore: memoryStore() }));
expect(container.querySelector('[data-testid="atlas-galaxy-legend"]')).toBeNull();
expect(toggle()?.getAttribute('aria-expanded')).toBe('false');
expect(seam().legendOpen).toBe(false);
});
it('steht unter dem Kopf und erklaert mindestens drei Elemente', async () => {
await render(props({ legendStore: openStore() }));
expect(container.querySelector('[data-testid="atlas-galaxy-legend"]')).not.toBeNull();
expect(legendEntries().length).toBeGreaterThanOrEqual(3);
expect(seam().legendEntries).toBe(legendEntries().length);
});
it('zeigt die Kantenfarben dieses Layouts als farbige Punkte', async () => {
await render(props({ legendStore: openStore() }));
const swatches = [...container.querySelectorAll('[data-testid="atlas-galaxy-legend-swatch"]')];
expect(swatches.map((swatch) => swatch.getAttribute('data-type')))
.toEqual(['CALLS', 'WHAT_IS_THIS']);
// CALLS steht in der Tabelle, WHAT_IS_THIS nicht: der zweite bekommt
// die Vorgabefarbe, die auch die Szene malt.
expect(swatches[0]?.getAttribute('data-color')).toBe('#579fc7');
expect(swatches[1]?.getAttribute('data-color')).toBe('#84939d');
});
/*
* Die Legende als Filter (W9).
*
* Gemessen wird am DOM und am Griff und nicht am Bild: ob die Linie
* wirklich verschwindet, ist eine Frage an einen WebGL-Kontext, und die
* stellt tools/smoke-w9.mjs mit einer Pixelanalyse. Hier zaehlt, dass die
* Szene die Kante gar nicht erst bekommt, dass die Zeile stehen bleibt und
* dass der Kopf die Zahl nennt.
*/
it('zaehlt jede Art und nennt ihre Zahl in der Zeile', async () => {
await render(props({ legendStore: openStore() }));
const swatches = [...container.querySelectorAll('[data-testid="atlas-galaxy-legend-swatch"]')];
expect(swatches.map((swatch) => swatch.getAttribute('data-count'))).toEqual(['1', '1']);
expect(swatches[0]?.textContent).toContain('CALLS 1');
expect(seam().edgeKinds.map((kind) => kind.type)).toEqual(['CALLS', 'WHAT_IS_THIS']);
expect(seam().edgeKinds.every((kind) => kind.hidden === false)).toBe(true);
expect(seam().drawnEdges).toBe(2);
expect(seam().edgeNote).toBe('2 edge kinds');
});
it('nimmt eine angeklickte Art aus dem Bild und laesst ihre Zeile stehen', async () => {
await render(props({ legendStore: openStore() }));
const row = () => container.querySelector<HTMLButtonElement>(
'[data-testid="atlas-galaxy-legend-swatch"][data-type="CALLS"]',
);
expect(row()?.tagName).toBe('BUTTON');
await act(async () => {
row()?.click();
});
expect(row()).not.toBeNull();
expect(row()?.getAttribute('data-hidden')).toBe('true');
expect(row()?.getAttribute('aria-pressed')).toBe('false');
expect(row()?.textContent).toContain('CALLS 1');
expect(seam().hiddenKinds).toEqual(['CALLS']);
expect(seam().drawnEdges).toBe(1);
expect(seam().edgeNote).toBe('2 edge kinds, 1 of 2 hidden');
expect(edgeNoteText()).toBe('2 edge kinds, 1 of 2 hidden');
expect(headlineText()).toContain('3 nodes, 2 edges from /api/layout');
// Und ein zweiter Klick holt sie zurueck.
await act(async () => {
row()?.click();
});
expect(row()?.getAttribute('data-hidden')).toBe('false');
expect(seam().drawnEdges).toBe(2);
expect(edgeNoteText()).toBe('2 edge kinds');
});
it('laesst die Nachbarschaft am ganzen Bild haengen, nicht am Filter', async () => {
await render(props({ legendStore: openStore() }));
await act(async () => {
container.querySelector<HTMLButtonElement>(
'[data-testid="atlas-galaxy-legend-swatch"][data-type="WHAT_IS_THIS"]',
)?.click();
});
await act(async () => {
seam().clickNode('atlas.src.services.userService.createUser');
});
// Beide Nachbarn, obwohl die Kante zu DB_URL gerade nicht gezeichnet
// wird: Nachbar ist, wen der Index nennt.
expect(seam().highlightedCount).toBe(3);
});
it('traegt am Kopf einen Schalter mit einem Wort und aria-expanded', async () => {
await render(props({ legendStore: openStore() }));
expect(toggle()?.getAttribute('aria-expanded')).toBe('true');
// Wort statt Pfeil seit W8b: der Nutzer hat die Zeichen nicht verstanden.
expect(toggle()?.textContent).toContain('hide legend');
});
it('klappt auf Klick auf und wieder zu', async () => {
await render(props({ legendStore: memoryStore() }));
await act(async () => {
toggle()?.click();
});
expect(container.querySelector('[data-testid="atlas-galaxy-legend"]')).not.toBeNull();
expect(toggle()?.getAttribute('aria-expanded')).toBe('true');
// Wort statt Pfeil seit W8b: der Nutzer hat die Zeichen nicht verstanden.
expect(toggle()?.textContent).toContain('hide legend');
expect(seam().legendOpen).toBe(true);
await act(async () => {
toggle()?.click();
});
expect(container.querySelector('[data-testid="atlas-galaxy-legend"]')).toBeNull();
});
it('merkt sich den Zustand ueber ein neues Mounten hinweg', async () => {
const store = memoryStore();
await render(props({ legendStore: store }));
await act(async () => {
toggle()?.click();
});
await act(async () => {
root.unmount();
});
root = createRoot(container);
await render(props({ legendStore: store }));
expect(container.querySelector('[data-testid="atlas-galaxy-legend"]')).not.toBeNull();
expect(toggle()?.getAttribute('aria-expanded')).toBe('true');
});
});
/*
* Die Hierarchie-Ansicht (W4e).
*
* Auch hier faellt kein Pixel: gemessen wird der Griff und das DOM des Kopfes.
* Dass die Szene die Projektion wirklich zeichnet und dabei denselben Canvas
* behaelt, beweist der Browserlauf (tools/smoke-w4e.mjs); was hier bewiesen
* wird, ist die Entscheidung darueber, welches Bild dransteht, was der Kopf
* dazu sagt und woran der Klick danach geht.
*/
const WALK_QN = {
createUser: 'atlas.src.services.userService.createUser',
validateUser: 'atlas.src.util.validate.validateUser',
listUsers: 'atlas.src.services.userService.listUsers',
query: 'atlas.src.repo.db.query',
};
function walkSymbol(name: keyof typeof WALK_QN, file: string, line: number): SymbolRef {
return {
name,
qualifiedName: WALK_QN[name],
kind: 'function',
uri: `file:///workspace/${file}`,
range: toEditorRange(line, line + 4),
selectionRange: toEditorRange(line, line),
};
}
function walkOf(overrides: Partial<ClosureResult> = {}): ClosureResult {
const root = walkSymbol('createUser', 'src/services/userService.ts', 23);
return {
root,
nodes: [
{ symbol: root, hop: 0 },
{
symbol: walkSymbol('validateUser', 'src/util/validate.ts', 19),
hop: 1,
via: WALK_QN.createUser,
},
{
symbol: walkSymbol('listUsers', 'src/services/userService.ts', 18),
hop: 1,
via: WALK_QN.createUser,
},
{
symbol: walkSymbol('query', 'src/repo/db.ts', 17),
hop: 2,
via: WALK_QN.listUsers,
},
],
edges: [
{ from: WALK_QN.createUser, to: WALK_QN.validateUser, line: 24 },
{ from: WALK_QN.createUser, to: WALK_QN.listUsers, line: 29 },
{ from: WALK_QN.listUsers, to: WALK_QN.query, line: 19 },
],
truncated: false,
visited: 4,
depth: 3,
cap: 15,
...overrides,
};
}
const modeChip = (mode: string) =>
container.querySelector<HTMLButtonElement>(
`[data-testid="atlas-graph-mode-chip"][data-mode="${mode}"]`,
);
const legendKeys = () =>
[...container.querySelectorAll('[data-testid="atlas-galaxy-legend-entry"]')]
.map((entry) => entry.getAttribute('data-entry'));
describe('GalaxyPanel und die Hierarchie', () => {
it('bleibt bei der Galaxie, solange es keinen Walk gibt', async () => {
await render(props());
expect(container.querySelector('[data-testid="atlas-graph-mode"]')?.getAttribute('data-mode'))
.toBe('galaxy');
expect(seam().mode).toBe('galaxy');
expect(seam().hierarchyAvailable).toBe(false);
expect(seam().hierarchy).toBeUndefined();
// The initial view stays unchanged, but hierarchy can open its root chooser.
expect(modeChip('hierarchy')?.getAttribute('aria-disabled')).toBe('false');
expect(modeChip('hierarchy')?.getAttribute('data-hint')).toContain('open a symbol');
expect(headlineText()).toContain('3 nodes, 2 edges from /api/layout');
});
it('schaltet von selbst auf hierarchy, sobald ein Walk laeuft', async () => {
await render(props({ walk: walkOf() }));
expect(seam().mode).toBe('hierarchy');
expect(modeChip('hierarchy')?.getAttribute('aria-pressed')).toBe('true');
expect(modeChip('galaxy')?.getAttribute('aria-pressed')).toBe('false');
expect(headlineText()).toBe('hierarchy of createUser: 4 symbols, depth 3');
expect(seam().headline).toBe(headlineText());
// Woraus die Linien bestehen, steht in der zweiten Zeile des Kopfes.
expect(edgeNoteText())
.toBe('3 calls from the walk, 0 links from the index; 1 edge kind');
});
it('legt eine Spalte je Hop an und nennt sie im Griff', async () => {
await render(props({ walk: walkOf() }));
const hierarchy = seam().hierarchy!;
expect(hierarchy.nodes).toBe(4);
expect(hierarchy.depth).toBe(3);
expect(hierarchy.root).toBe(WALK_QN.createUser);
const byHop = new Map<number, number[]>();
for (const placement of hierarchy.placements) {
byHop.set(placement.hop, [...(byHop.get(placement.hop) ?? []), placement.x]);
}
expect([...byHop.keys()].sort()).toEqual([0, 1, 2]);
expect(byHop.get(0)).toEqual([0]);
expect(byHop.get(1)).toEqual([HIERARCHY_COLUMN_WIDTH, HIERARCHY_COLUMN_WIDTH]);
expect(byHop.get(2)).toEqual([HIERARCHY_COLUMN_WIDTH * 2]);
expect(hierarchy.edges).toEqual([
{ from: WALK_QN.createUser, to: WALK_QN.validateUser },
{ from: WALK_QN.createUser, to: WALK_QN.listUsers },
{ from: WALK_QN.listUsers, to: WALK_QN.query },
]);
});
it('nennt den Deckel im Kopf, wenn der Walk gekappt wurde', async () => {
await render(props({ walk: walkOf({ truncated: true, cap: 3, visited: 9 }) }));
expect(headlineText()).toContain('hierarchy of createUser: 4 symbols, depth 3');
expect(headlineText()).toContain('walk capped at 3 symbols (depth 3)');
});
it('schaltet auf Klick zurueck zur Galaxie und behaelt die Wahl', async () => {
await render(props({ walk: walkOf() }));
await act(async () => {
modeChip('galaxy')?.click();
});
expect(seam().mode).toBe('galaxy');
expect(headlineText()).toContain('3 nodes, 2 edges from /api/layout');
// Ein neues Bild derselben Sitzung darf die Entscheidung nicht kippen.
await render(props({ walk: walkOf(), focusQualifiedName: WALK_QN.createUser }));
expect(seam().mode).toBe('galaxy');
await act(async () => {
modeChip('hierarchy')?.click();
});
expect(seam().mode).toBe('hierarchy');
});
/*
* Die uebrigen Beziehungen im Bild (W9).
*
* Das Layout dieses Falls traegt eine RAISES-Kante zwischen zwei Symbolen,
* die auch im Walk stehen. Gemessen wird dreierlei: dass sie im Bild landet,
* dass sie eine eigene Spur bekommt (sonst laege sie auf der Aufrufkante und
* mischte sich additiv zu einer Farbe, die in keiner Legende steht), und
* dass die Spalten davon unberuehrt bleiben.
*/
const raisingLayout = () => ({
...LAYOUT,
edges: [...LAYOUT.edges, { source: 51, target: 69, type: 'RAISES' }],
});
const raisingFetch = () =>
vi.fn(async () => new Response(JSON.stringify(raisingLayout()), { status: 200 })) as
unknown as typeof fetch;
it('legt die uebrigen Beziehungen des Index dazu, jede auf ihrer Spur', async () => {
await render(props({ walk: walkOf(), fetch: raisingFetch() }));
const hierarchy = seam().hierarchy!;
expect(hierarchy.walkEdges).toBe(3);
expect(hierarchy.extraEdges).toBe(1);
expect(hierarchy.extras).toEqual([
{
type: 'RAISES',
from: WALK_QN.createUser,
to: WALK_QN.validateUser,
offset: HIERARCHY_LANE_SPACING,
},
]);
expect(seam().drawnEdges).toBe(4);
expect(edgeNoteText())
.toBe('3 calls from the walk, 1 link from the index; 2 edge kinds');
expect(headlineText()).toBe('hierarchy of createUser: 4 symbols, depth 3');
});
it('ordnet mit den zusaetzlichen Kanten nichts um', async () => {
await render(props({ walk: walkOf() }));
const plain = seam().hierarchy!.placements;
await act(async () => {
root.unmount();
});
root = createRoot(container);
await render(props({ walk: walkOf(), fetch: raisingFetch() }));
expect(seam().hierarchy!.placements).toEqual(plain);
});
it('haengt die zusaetzlichen Kanten an denselben Filter', async () => {
await render(props({ walk: walkOf(), fetch: raisingFetch(), legendStore: openStore() }));
expect(seam().edgeKinds.map((kind) => kind.type)).toEqual(['CALLS', 'RAISES']);
expect(seam().edgeKinds.map((kind) => kind.count)).toEqual([3, 1]);
await act(async () => {
container.querySelector<HTMLButtonElement>(
'[data-testid="atlas-galaxy-legend-swatch"][data-type="RAISES"]',
)?.click();
});
expect(seam().drawnEdges).toBe(3);
expect(edgeNoteText())
.toBe('3 calls from the walk, 1 link from the index; 2 edge kinds, 1 of 2 hidden');
// Der Zustand ueberlebt den Wechsel in die andere Ansicht.
await act(async () => {
modeChip('galaxy')?.click();
});
expect(seam().mode).toBe('galaxy');
expect(seam().hiddenKinds).toEqual(['RAISES']);
});
it('tauscht die Legende gegen die Saetze der Projektion', async () => {
await render(props({ walk: walkOf(), legendStore: openStore() }));
expect(legendKeys())
.toEqual(['edge-color', 'positions', 'node-color', 'node-size', 'focus', 'agent-trail']);
const positions = container.querySelector('[data-entry="positions"]')?.textContent ?? '';
expect(positions).toContain('call depth from the entry point');
expect(positions).toContain('not the server layout');
await act(async () => {
modeChip('galaxy')?.click();
});
expect(legendKeys())
.toEqual(['edge-color', 'node-color', 'node-size', 'focus', 'positions', 'agent-trail']);
expect(container.querySelector('[data-entry="positions"]')?.textContent)
.toContain('computed by the server');
});
it('faerbt aus dem Layout, wo es das Symbol kennt, und bleibt sonst neutral', async () => {
await render(props({ walk: walkOf() }));
// Der Griff nennt keine Farben; geprueft wird die Quelle ueber die
// Projektion selbst in hierarchy-layout.test.ts. Hier zaehlt, dass das
// Panel das geladene Layout ueberhaupt weiterreicht: ohne es waere die
// Zahl der Knoten dieselbe, aber der Kopf spraeche von einem Bild ohne
// jede Server-Angabe.
expect(seam().nodes).toBe(3);
expect(seam().hierarchy?.nodes).toBe(4);
});
it('folgt mit dem Ring dem Symbol vor dem Leser', async () => {
await render(props({ walk: walkOf(), focusQualifiedName: WALK_QN.createUser }));
expect(seam().pulsedQn).toBe(WALK_QN.createUser);
await render(props({ walk: walkOf(), focusQualifiedName: WALK_QN.query }));
expect(seam().pulsedQn).toBe(WALK_QN.query);
});
it('faellt auf den Schritt zurueck, wenn der Leser ausserhalb des Walks steht', async () => {
await render(props({
walk: walkOf(),
focusQualifiedName: 'atlas.src.nowhere.hidden',
stepQualifiedName: WALK_QN.listUsers,
}));
expect(seam().pulsedQn).toBe(WALK_QN.listUsers);
});
it('sagt es, wenn nichts von diesem Walk im Fokus steht', async () => {
await render(props({ walk: walkOf() }));
expect(seam().pulsedQn).toBe('');
// Runde 4 (N2): in einfachen Worten, und nur neben dem Reader von Explore.
expect(noteText()).toBe('None of these nodes is open in Explore; the ring marks the symbol open there.');
});
it('oeffnet einen angeklickten Knoten der Projektion ueber denselben Weg', async () => {
const onOpenNode = vi.fn();
await render(props({ walk: walkOf(), onOpenNode }));
let found = false;
await act(async () => {
found = seam().clickNode(WALK_QN.query);
});
expect(found).toBe(true);
expect(onOpenNode).toHaveBeenCalledTimes(1);
expect(onOpenNode.mock.calls[0][0]).toMatchObject({
name: 'query',
file_path: 'src/repo/db.ts',
start_line: 17,
});
// Ein Knoten der Galaxie, der nicht im Walk vorkommt, ist hier kein Ziel.
let alien = true;
await act(async () => {
alien = seam().clickNode('__env__DB_URL');
});
expect(alien).toBe(false);
});
});
/*
* Die vier Kleinigkeiten aus W10b, soweit sie ohne einen Pixel messbar sind.
*
* Der Ansichts-Schalter klappt (AC2), die Hierarchie waechst aus dem Fokus
* (AC3), und der Kopf sagt, woher ihre Wurzel kommt. Was hier NICHT geprueft
* wird, ist die Einpassung der Kamera: sie ist eine Aussage ueber ein Bild, und
* in jsdom gibt es keines. Sie steht als Rechnung in camera-frame.test.ts und
* als Messung am gerenderten Bild in tools/smoke-w10b.mjs.
*/
/**
* Ein ResizeObserver, der nie etwas meldet.
*
* Die Tests darunter fahren das Panel AUFGEKLAPPT (`visible: true`), denn genau
* darum geht es in AC2: was ein Klick tut, haengt daran, ob die Sektion offen
* ist. Aufgeklappt haengt die Szene im Baum, und der Canvas der Uebernahme misst
* sich selbst mit react-use-measure, das ohne ResizeObserver sofort abbricht.
* Der Stummel meldet nie eine Groesse, der Canvas bleibt damit bei null mal null
* und baut gar keinen WebGL-Kontext auf: was hier gemessen wird, ist das DOM des
* Kopfes, und das Bild misst tools/smoke-w10b.mjs im Browser.
*/
class SilentResizeObserver {
observe(): void {
/* meldet nichts: siehe Kopf */
}
unobserve(): void {
/* dito */
}
disconnect(): void {
/* dito */
}
}
const withScene = (): void => {
(globalThis as unknown as Record<string, unknown>).ResizeObserver ??= SilentResizeObserver;
};
describe('hierarchy selection regression', () => {
beforeEach(withScene);
it('keeps an explicit entry-point walk when the reader has a file selected', async () => {
await render(props({ walk: walkOf(), focusFilePath: 'src/services/userService.ts' }));
expect(seam().mode).toBe('hierarchy');
expect(seam().hierarchyOrigin).toBe('walk');
expect(seam().hierarchy?.root).toBe(WALK_QN.createUser);
expect(seam().hierarchy?.nodes).toBe(4);
});
it('resolves a hierarchy render ID collision to the canonical selected symbol', async () => {
const unrelated = { ...LAYOUT.nodes[2]!, id: 0 };
const fetchLayout = vi.fn(async () => new Response(JSON.stringify({
...LAYOUT, nodes: [unrelated, ...LAYOUT.nodes],
}), { status: 200 }));
const onSelectNode = vi.fn();
await render(props({ workspaceExpanded: true, focusWalk: walkOf(), onSelectNode,
fetch: fetchLayout as unknown as typeof fetch }));
await act(async () => { modeChip('hierarchy')?.click(); });
await act(async () => { seam().clickNode(WALK_QN.createUser); });
expect(onSelectNode).toHaveBeenCalledWith(expect.objectContaining({
id: 51, qualified_name: WALK_QN.createUser,
}));
});
it('selects a root from the node picker after entering hierarchy in the mini graph', async () => {
const onSelectNode = vi.fn();
await render(props());
await act(async () => { modeChip('hierarchy')?.click(); });
await render(props({ workspaceExpanded: true, onSelectNode }));
expect(seam().mode).toBe('hierarchy');
expect(seam().hierarchy).toBeUndefined();
await act(async () => container.querySelector<HTMLInputElement>('[aria-label="Find a graph node"]')!.focus());
const result = [...container.querySelectorAll<HTMLButtonElement>('.atlas-galaxy-node-picker button')]
.find(button => button.textContent?.includes('createUser'));
expect(result).toBeDefined();
await act(async () => { result!.click(); });
expect(onSelectNode).toHaveBeenCalledWith(expect.objectContaining({
id: 51, qualified_name: LAYOUT.nodes[0]!.qualified_name,
}));
expect(seam().mode).toBe('hierarchy');
});
it('lets the user enter hierarchy before choosing a root and gives a next action', async () => {
await render(props({ visible: true, workspaceExpanded: true }));
await act(async () => { modeChip('hierarchy')?.click(); });
expect(seam().mode).toBe('hierarchy');
expect(container.querySelector('[data-testid="atlas-hierarchy-choose-root"]')).not.toBeNull();
});
it('keeps hierarchy selected when the selected root changes and its walk is loading', async () => {
await render(props({ visible: true, focusWalk: walkOf() }));
await act(async () => { modeChip('hierarchy')?.click(); });
expect(seam().mode).toBe('hierarchy');
await render(props({ visible: true, focusQualifiedName: 'atlas.nextRoot', focusWalkStatus: 'loading', focusWalkMessage: 'Loading nextRoot…' }));
expect(seam().mode).toBe('hierarchy');
expect(seam().hierarchy).toBeUndefined();
expect(headlineText()).toBe('Loading nextRoot…');
});
it('does not collapse hierarchy when its active mode button is clicked again', async () => {
const onToggleVisible = vi.fn();
await render(props({ visible: true, focusWalk: walkOf(), onToggleVisible }));
await act(async () => { modeChip('hierarchy')?.click(); });
await act(async () => { modeChip('hierarchy')?.click(); });
expect(seam().mode).toBe('hierarchy');
expect(onToggleVisible).not.toHaveBeenCalled();
});
});
describe('mini galaxy follows the code reader', () => {
const waitForReader = (assertion: () => void) => vi.waitFor(async () => {
await act(async () => { await new Promise(resolve => setTimeout(resolve, 0)); });
assertion();
});
it('frames the active file even when no twin symbol is available', async () => {
await render(props({ focusFilePath: 'src/services/userService.ts' }));
await waitForReader(() => expect(seam().highlightedCount).toBe(1));
expect(seam().lastTargetQn).toBe('src/services/userService.ts');
expect(noteText()).toBe('');
});
it('uses the selected source range and clears highlights for an absent file', async () => {
await render(props({ focusFilePath: 'src/util/validate.ts', focusSourceRange: { startLine: 20, endLine: 21 } }));
await waitForReader(() => expect(seam().highlightedCount).toBe(1));
expect(seam().lastTargetQn).toBe('src/util/validate.ts');
await render(props({ focusFilePath: 'src/missing.ts' }));
expect(seam().highlightedCount).toBe(0);
await waitForReader(() => expect(noteText()).toContain('src/missing.ts is not in the loaded graph layout'));
});
it('falls back to file context when its focused symbol is outside the layout budget', async () => {
await render(props({ focusFilePath: 'src/util/validate.ts', focusQualifiedName: 'atlas.notLoaded' }));
await waitForReader(() => expect(seam().highlightedCount).toBe(1));
expect(seam().lastTargetQn).toBe('src/util/validate.ts');
await render(props({ focusFilePath: '' }));
expect(seam().highlightedCount).toBe(0);
});
it('shows a single leaf root and its honest outgoing-call note', async () => {
const walk = walkOf();
const leaf: ClosureResult = { ...walk, nodes: [walk.nodes[0]!], edges: [], truncated: false, visited: 1 };
await render(props({ focusWalk: leaf, focusWalkStatus: 'ready', focusWalkMessage: 'No outgoing calls are recorded for this symbol.' }));
await act(async () => { modeChip('hierarchy')?.click(); });
expect(seam().hierarchy?.nodes).toBe(1);
expect(seam().drawnEdges).toBe(0);
expect(edgeNoteText()).toContain('No outgoing calls are recorded');
});
});
describe('GalaxyPanel: der Ansichts-Schalter klappt auch', () => {
beforeEach(withScene);
it('klappt auf einen Klick auf den aktiven Knopf zu', async () => {
const onToggleVisible = vi.fn();
await render(props({ visible: true, onToggleVisible }));
expect(seam().mode).toBe('galaxy');
await act(async () => {
modeChip('galaxy')?.click();
});
expect(onToggleVisible).toHaveBeenCalledTimes(1);
// Die Ansicht bleibt gewaehlt: zugeklappt ist keine dritte Ansicht.
expect(seam().mode).toBe('galaxy');
expect(modeChip('galaxy')?.getAttribute('data-action')).toBe('collapse');
});
it('klappt bei zugeklappter Sektion auf und waehlt dabei die Ansicht', async () => {
const onToggleVisible = vi.fn();
await render(props({ visible: false, walk: walkOf(), onToggleVisible }));
expect(modeChip('hierarchy')?.getAttribute('data-action')).toBe('open');
await act(async () => {
modeChip('hierarchy')?.click();
});
expect(onToggleVisible).toHaveBeenCalledTimes(1);
expect(seam().mode).toBe('hierarchy');
});
it('wechselt die Ansicht wie bisher, solange die Sektion offen ist', async () => {
const onToggleVisible = vi.fn();
await render(props({ visible: true, walk: walkOf(), onToggleVisible }));
await act(async () => {
modeChip('galaxy')?.click();
});
expect(onToggleVisible).not.toHaveBeenCalled();
expect(seam().mode).toBe('galaxy');
expect(modeChip('hierarchy')?.getAttribute('data-action')).toBe('switch');
});
it('geht denselben Weg wie der beschriftete Schalter daneben', async () => {
const onToggleVisible = vi.fn();
await render(props({ visible: true, onToggleVisible }));
await act(async () => {
container.querySelector<HTMLButtonElement>(
'[data-testid="atlas-galaxy-collapse"]',
)?.click();
});
const viaLabel = onToggleVisible.mock.calls.length;
await act(async () => {
modeChip('galaxy')?.click();
});
// Beide Wege rufen denselben Rueckruf, also koennen sie nicht in zwei
// verschiedene Zustaende fuehren.
expect(onToggleVisible.mock.calls.length).toBe(viaLabel + 1);
});
it('offers a root chooser instead of disabling hierarchy', async () => {
await render(props({ visible: true }));
const chip = modeChip('hierarchy');
expect(chip?.getAttribute('aria-disabled')).toBe('false');
expect(chip?.getAttribute('data-action')).toBe('switch');
await act(async () => {
chip?.click();
});
expect(seam().mode).toBe('hierarchy');
expect(headlineText()).toContain('Choose a symbol');
});
});
describe('GalaxyPanel: die Hierarchie aus dem Fokus', () => {
beforeEach(withScene);
it('baut die Projektion auch ohne Walk, aus dem Symbol im Fokus', async () => {
await render(props({ visible: true, focusWalk: walkOf() }));
expect(seam().hierarchyAvailable).toBe(true);
expect(seam().hierarchyOrigin).toBe('focus');
expect(modeChip('hierarchy')?.getAttribute('aria-disabled')).toBe('false');
// Aber sie waehlt sich nicht selbst: ein Fokus entsteht bei jedem Klick
// in den Code (Entscheidung 17).
expect(seam().mode).toBe('galaxy');
});
it('zeigt sie auf Klick und nennt im Kopf die Herkunft der Wurzel', async () => {
await render(props({ visible: true, focusWalk: walkOf() }));
await act(async () => {
modeChip('hierarchy')?.click();
});
expect(seam().mode).toBe('hierarchy');
expect(headlineText()).toBe('hierarchy of createUser (in focus): 4 symbols, depth 3');
expect(seam().hierarchy?.nodes).toBe(4);
});
it('laesst dem echten Spaziergang den Vortritt', async () => {
const other = walkOf();
const entry = {
...other,
root: { ...other.root, name: 'listUsers' },
};
await render(props({ visible: true, walk: entry, focusWalk: walkOf() }));
expect(seam().hierarchyOrigin).toBe('walk');
expect(seam().mode).toBe('hierarchy');
expect(headlineText()).toBe('hierarchy of listUsers: 4 symbols, depth 3');
});
it('ordnet die Spalten aus dem Fokus genau wie aus einem Walk', async () => {
await render(props({ visible: true, walk: walkOf() }));
const fromWalk = seam().hierarchy!.placements;
await act(async () => {
root.unmount();
});
root = createRoot(container);
await render(props({ visible: true, focusWalk: walkOf() }));
await act(async () => {
modeChip('hierarchy')?.click();
});
expect(seam().hierarchy!.placements).toEqual(fromWalk);
});
});
it('keeps graph selection evidence collapsed until explicitly inspected', async () => {
await render(props({ workspaceExpanded: true, selectionPanel: <p>Selected relationship evidence</p> }));
const details = container.querySelector<HTMLDetailsElement>('.atlas-galaxy-selection-details')!;
expect(details).not.toBeNull();
expect(details.open).toBe(false);
expect(details.querySelector('summary')?.textContent).toBe('Selection details');
await act(async () => { details.querySelector('summary')!.click(); });
expect(details.open).toBe(true);
expect(details.textContent).toContain('Selected relationship evidence');
});