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
/*
* Was der Tiefenregler aendern darf und was nicht.
*
* Portiert aus CodeAtlasIDE,
* theia-extensions/codeatlas-views/test/render-model.test.ts. Ein Unterschied,
* und er ist Absicht: das Referenzprojekt fuehrt eine committete
* Snapshot-Datei, die vierzig Renderergebnisse festhaelt. Die kommt hier NICHT
* mit. Ein Snapshot ist nur so viel wert wie der Reviewer, der seinen Diff
* annimmt; ohne den Review-Weg des anderen Projekts waere er eine Datei, die
* bei jeder Aenderung neu geschrieben und nie gelesen wird. Stattdessen sind
* die zentralen Erwartungen hier direkt festgenagelt: dieselben Aussagen, nur
* so geschrieben, dass beim Brechen dasteht, WAS sich geaendert hat.
*
* Zwei der Zusicherungen sind die Behauptung des Produkts und nicht sein
* Verhalten: die Erzaehl-Tiefe darf keinen qualifizierten Namen und keine
* Konfidenz zeigen, und eine Linse, die der Leser ausgeschaltet hat, darf ihre
* Sektion nicht zuruecklassen.
*/
import { describe, expect, it } from 'vitest';
import {
ALL_FACETS,
CORE_FACETS,
CREATE_USER_IR,
NARROW_FACETS,
QUALIFIED_NAME,
QUALIFIED_SHAPE,
presentation,
sectionNames,
} from '../test-support/twin-fixtures';
import { buildImportsGroup } from '../pseudocode/imports-group';
import { Facet } from './presentation-profile';
import type { DepthLevel } from './presentation-profile';
import {
buildTwinViewModel,
topFacts,
visibleSections,
visibleTextOf,
withImportsSection,
} from './render-model';
describe('buildTwinViewModel: eine IR, fuenf Leser', () => {
it('nennt seine Bauform an jeder Raste ehrlich', () => {
const modes = ([0, 1, 2, 3, 4] as const).map(
(depth) => buildTwinViewModel(CREATE_USER_IR, presentation(depth, CORE_FACETS)).mode,
);
expect(modes).toEqual(['prose', 'guided', 'sections', 'cost', 'ground']);
});
it('rendert auf jeder Stufe etwas, statt leer zu bleiben', () => {
for (const depth of [0, 1, 2, 3, 4] as const) {
const text = visibleTextOf(buildTwinViewModel(CREATE_USER_IR, presentation(depth, CORE_FACETS)));
expect(text.trim().length, `Stufe ${depth} rendert nichts`).toBeGreaterThan(0);
}
});
it('stellt jeder Stufe ihre eigene Frage voran', () => {
const questions = ([0, 1, 2, 3, 4] as const).map(
(depth) => buildTwinViewModel(CREATE_USER_IR, presentation(depth, CORE_FACETS)).question,
);
// Fuenf verschiedene Fragen, und keine leer: die Frage ist das eine
// Element, das jede Stufe hat, und der erste Satz, den ein Leser sieht.
expect(new Set(questions).size).toBe(5);
for (const question of questions) {
expect(question.length).toBeGreaterThan(0);
}
});
/*
* AC1 dieses Zyklus, als Zusicherung statt als Zusage.
*
* Der Nutzerbefund lautete "ich seh gar keine Aenderungen", und die einzige
* Antwort darauf, die etwas wert ist, ist eine Messung: derselbe Text an
* zwei Rasten waere ein Regler, der nichts tut, und ein Beweislauf im
* Browser findet das spaeter und teurer als diese Zeile hier.
*/
it('sagt an keinen zwei Stufen dasselbe', () => {
const texts = ([0, 1, 2, 3, 4] as const).map(
(depth) => visibleTextOf(buildTwinViewModel(CREATE_USER_IR, presentation(depth, CORE_FACETS))),
);
expect(new Set(texts).size).toBe(5);
});
});
describe('die Erzaehl-Tiefe sagt nichts, wonach niemand gefragt hat', () => {
const model = buildTwinViewModel(CREATE_USER_IR, presentation(0, ALL_FACETS));
/**
* Was der Leser sieht. Nicht eine Serialisierung des ganzen Modells: ein
* Chip traegt das Navigationsziel, an dem der Twin sein Subjekt neu
* verankert, dessen qualifizierter Name nie gerendert wird, und eine
* Zusicherung darueber wuerde die Chips zwingen, die Identitaet abzulegen,
* die sie anklickbar macht.
*/
const text = visibleTextOf(model);
it('ist Prosa', () => {
expect(model.mode).toBe('prose');
expect(model.paragraphs.length).toBeGreaterThan(0);
expect(model.sections).toHaveLength(0);
expect(model.facts).toHaveLength(0);
});
it('zeigt nirgends einen qualifizierten Namen', () => {
expect(QUALIFIED_NAME).toMatch(QUALIFIED_SHAPE);
expect(text).not.toMatch(QUALIFIED_SHAPE);
expect(text).not.toContain(QUALIFIED_NAME);
});
it('zeigt keine Konfidenz-Zahl', () => {
expect(text).not.toContain('confidence');
expect(text).not.toContain('0.9');
});
it('nennt Aufgerufenes als blosse Namen, bei fuenf gedeckelt, und sagt, wie viele fehlen', () => {
expect(model.chips).toHaveLength(5);
for (const chip of model.chips) {
expect(chip.label).not.toContain('.');
expect(chip.target).toBeDefined();
}
expect(model.chips.map((chip) => chip.label)).toEqual([
'validateUser',
'ValidationError',
'UserEntity',
'listUsers',
'insert',
]);
expect(text).toContain('1 further part is not listed here');
});
it('behaelt das Ziel, das einen Chip folgbar macht, obwohl es nie gezeigt wird', () => {
expect(model.chips[0].target?.qualifiedName).toMatch(QUALIFIED_SHAPE);
});
it('sagt laut, dass der Absatz erzeugt wurde', () => {
expect(text).toContain('Nobody wrote that description');
});
/*
* W7a (Nutzerauftrag 2026-08-29): die beiden Linsen sagen nicht mehr, dass
* sie "noch nicht gebaut" seien, sondern wo die Antwort in DIESEM Produkt
* wirklich steht. Der Twin traegt sie nicht; der BUG-Assistent, der Flow und
* die Aenderungsansicht tun es.
*/
it('sagt von beiden Linsen, welche Flaeche sie stattdessen beantwortet', () => {
expect(text).toContain('not to the twin');
expect(text).toContain('ingest_traces');
expect(text).toContain('The twin carries no version history');
expect(text).toContain('[c]hange scope');
});
});
describe('die Junior-Stufe fuehrt mit der Reihenfolge', () => {
const model = buildTwinViewModel(CREATE_USER_IR, presentation(1, CORE_FACETS, 'plain'));
it('ist ein kurzer Absatz plus die Schritte in ihrer Ordnung', () => {
expect(model.mode).toBe('guided');
expect(model.paragraphs).toHaveLength(2);
expect(model.sections).toHaveLength(0);
expect(model.steps).toHaveLength(CREATE_USER_IR.steps.value.length);
expect(model.steps.map((step) => step.order)).toEqual([1, 2, 3, 4, 5, 6]);
});
it('setzt zwischen die Schritte ein Wort ueber die Reihenfolge, nie ueber die Absicht', () => {
const texts = model.steps.map((step) => step.text);
expect(texts[0].startsWith('First it hands work to validateUser')).toBe(true);
expect(texts[texts.length - 1].startsWith('And last')).toBe(true);
// Kein Bindeglied darf eine Absicht behaupten: der Index kennt die
// Reihenfolge und niemand kennt den Grund.
for (const text of texts) {
expect(text).not.toMatch(/\bbecause\b|\bso that\b|\bin order to\b/);
}
});
it('nennt den Ort, an den ein Schritt fuehrt, und laesst ihn anspringen', () => {
expect(model.steps[0].text).toContain('validate.ts:');
expect(model.steps[0].target).toBeDefined();
expect(model.steps[0].factPath).toBe('steps[0]');
});
it('erklaert ein Wort beim ersten Auftreten, und nur die benutzten', () => {
const words = model.terms.map((term) => term.term);
expect(words).toContain('call site');
expect(words).toContain('caller');
expect(words).toContain('raise');
// Die Fixture ist kein Einstiegspunkt (complexity ist unsupported), also
// darf das Wort auch nicht erklaert werden.
expect(words).not.toContain('entry point');
expect(new Set(words).size).toBe(words.length);
for (const term of model.terms) {
expect(term.explanation.length).toBeGreaterThan(20);
}
});
it('sagt es, wenn es gar keine Reihenfolge gibt, statt die Liste wegzulassen', () => {
const leaf = { ...CREATE_USER_IR, steps: { ...CREATE_USER_IR.steps, value: [] } };
const model = buildTwinViewModel(leaf, presentation(1, CORE_FACETS, 'plain'));
expect(model.steps).toHaveLength(0);
expect(visibleTextOf(model)).toContain('records no call order to walk through');
});
it('beschreibt ein Blatt nur als fehlenden aufgeloesten Aufruf, nicht als vollstaendiges Verhalten', () => {
const leaf = { ...CREATE_USER_IR, steps: { ...CREATE_USER_IR.steps, value: [] } };
const prose = buildTwinViewModel(leaf, presentation(0, CORE_FACETS, 'plain'));
const guided = buildTwinViewModel(leaf, presentation(1, CORE_FACETS, 'plain'));
expect(prose.subject).toMatch(/^createUser is a .+ \d+ lines in .+\.ts\./i);
expect(prose.subject).toContain('The index resolves no outgoing calls');
expect(prose.subject).not.toMatch(/works alone|complete recorded behavior/i);
expect(visibleTextOf(guided)).toContain('The index resolves no outgoing calls');
expect(visibleTextOf(guided)).not.toMatch(/does its work by itself|works alone|no shared state/i);
});
});
describe('die Breite-zuerst-Liste, die keine Stufe mehr fuehrt', () => {
it('nimmt eine Zeile je Familie, bevor eine Familie eine zweite bekommt', () => {
const sections = visibleSections(CREATE_USER_IR, presentation(2, CORE_FACETS, 'plain'));
const facts = topFacts(sections, 5);
expect(facts.map((fact) => fact.label)).toEqual([
'What it does, in order',
'Who uses it',
'What it reads',
'How it can fail',
'What checks it',
]);
for (const fact of facts) {
expect(fact.name).not.toContain('.');
expect(fact.target).toBeDefined();
expect(fact.factPath.length).toBeGreaterThan(0);
}
});
});
describe('die technische Tiefe sind die aufgezeichneten Fakten, unveraendert', () => {
const model = buildTwinViewModel(CREATE_USER_IR, presentation(2, CORE_FACETS));
it('rendert Sektionen und keine Prosa', () => {
expect(model.mode).toBe('sections');
expect(model.paragraphs).toHaveLength(0);
expect(sectionNames(model)).toEqual([
'purpose',
'steps',
'callers',
'state',
'errors',
'effects',
'tests',
]);
});
it('zeigt Datei und Zeile, die die Erzaehl-Tiefe weglaesst', () => {
expect(visibleTextOf(model)).toContain('validate.ts:19');
});
it('haengt weder Konfidenz noch Zaehlung an', () => {
const text = visibleTextOf(model);
expect(text).not.toContain('confidence');
expect(text).not.toContain('entries');
});
});
describe('die Senior-Stufe fragt, was es kostet', () => {
const model = buildTwinViewModel(CREATE_USER_IR, presentation(3, CORE_FACETS));
const block = (name: string) => model.blocks.find((entry) => entry.name === name);
it('zeichnet vier Kostenbloecke und keine Sektionen', () => {
expect(model.mode).toBe('cost');
expect(model.sections).toHaveLength(0);
expect(model.blocks.map((entry) => entry.name))
.toEqual(['fails', 'unchecked', 'depends', 'moves']);
});
it('fuehrt jeden Block mit dem Satz, der die Frage stellt', () => {
for (const entry of model.blocks) {
expect(entry.lead.length).toBeGreaterThan(20);
expect(entry.emptyText.length).toBeGreaterThan(20);
}
});
it('zieht die Fehlerpfade aus derselben Sektion, die die Medior-Stufe zeigt', () => {
expect(block('fails')?.rows.map((row) => row.label)).toEqual(['ValidationError']);
});
it('zaehlt zusammen, was eine Aenderung mitbewegt', () => {
const moves = block('moves');
// Schritte, Umgebungslesungen und Effekte, nach Familie gruppiert.
expect(moves?.rows.length).toBe(8);
expect(new Set(moves?.rows.map((row) => row.group)).size).toBeGreaterThan(1);
expect(moves?.weight).toBe('8 places to check');
});
it('zeigt keine Konfidenz: die Frage ist der Preis und nicht die Herkunft', () => {
expect(visibleTextOf(model)).not.toContain('confidence');
});
it('sagt es in seiner eigenen Sprache, wo ein Block nichts zu bieten hat', () => {
const calm = {
...CREATE_USER_IR,
throws: { ...CREATE_USER_IR.throws, value: [] },
};
const empty = buildTwinViewModel(calm, presentation(3, CORE_FACETS));
expect(empty.blocks.find((entry) => entry.name === 'fails')?.rows).toHaveLength(0);
expect(visibleTextOf(empty)).toContain('No error path was recorded here');
});
it('nimmt einen Block mit seiner Linse weg', () => {
const noErrors = buildTwinViewModel(CREATE_USER_IR, presentation(3, NARROW_FACETS));
expect(noErrors.blocks.map((entry) => entry.name)).not.toContain('fails');
});
});
describe('die Architekten-Stufe fragt, worauf es sitzt', () => {
const model = buildTwinViewModel(CREATE_USER_IR, presentation(4, CORE_FACETS));
const text = visibleTextOf(model);
const block = (name: string) => model.blocks.find((entry) => entry.name === name);
it('zeichnet Grund, Traeger und Schulden statt Sektionen', () => {
expect(model.mode).toBe('ground');
expect(model.sections).toHaveLength(0);
expect(model.blocks.map((entry) => entry.name))
.toEqual(['sits-on', 'carried-by', 'debts']);
});
it('fasst die Aufrufe zu Modulen zusammen und sagt, wie oft jedes getroffen wird', () => {
const rows = block('sits-on')?.rows ?? [];
expect(rows.map((row) => row.label)).toEqual([
'util/validate.ts',
'src/types.ts',
'services/userService.ts',
'repo/db.ts',
]);
expect(rows[0].extras).toContain('2 call sites');
});
it('zeigt die Konfidenz, die der Provider aufgezeichnet hat', () => {
expect(text).toContain('confidence 0.90');
expect(block('sits-on')?.rows[0].confidenceLabel).toBe('confidence 0.90');
// Ein Modul, in das nur unbewertete Aufrufe fuehren, sagt, dass es
// nichts zu bewerten gab, statt eine Luecke zu lassen.
expect(block('sits-on')?.rows[3].confidenceLabel).toBe('exact');
});
it('haelt die Grenzen des Index als eigenen Block, nicht als Fussnote', () => {
expect(model.limits.length).toBeGreaterThan(4);
const kinds = new Set(model.limits.map((limit) => limit.kind));
expect(kinds).toContain('state');
expect(kinds).toContain('engine');
expect(kinds).toContain('generation');
expect(text).toContain('records no test relation for TypeScript');
expect(text).toContain('index generation 2');
});
it('sagt es, wo keine Regel gefeuert hat, statt einen sauberen Befund zu behaupten', () => {
expect(block('debts')?.rows).toHaveLength(0);
expect(text).toContain('That is not a clean bill');
});
it('behauptet keine Struktur-Kennzahl, die dieser Index gar nicht misst', () => {
// complexity ist in dieser Fixture `unsupported`, und die Nullen darin
// sind Platzhalter und keine Messwerte.
expect(CREATE_USER_IR.complexity.state).toBe('unsupported');
expect(text).not.toContain('branches through the body');
expect(text).not.toContain('Loops nested');
});
});
describe('die drei semantischen Bloecke', () => {
const model = buildTwinViewModel(CREATE_USER_IR, presentation(2, CORE_FACETS));
const block = (name: string) => model.sections.find((section) => section.name === name);
it('gruppiert, was das Symbol haelt, wie es scheitert und was es beruehrt', () => {
expect(block('state')?.block).toBe('data');
expect(block('errors')?.block).toBe('errors');
expect(block('effects')?.block).toBe('effects');
// Alles andere handelt vom Symbol selbst und nicht davon, was es
// erreicht, und wird darum absichtlich in keinen der drei gezwungen.
expect(block('purpose')?.block).toBeUndefined();
expect(block('steps')?.block).toBeUndefined();
expect(block('callers')?.block).toBeUndefined();
expect(block('tests')?.block).toBeUndefined();
});
it('zeichnet den Datenblock als Menge von Chips, mit allen Zielen und Belegen', () => {
const data = block('state');
expect(data?.rows.length).toBeGreaterThan(0);
for (const row of data?.rows ?? []) {
expect(row.display).toBe('chip');
expect(row.factPath.length).toBeGreaterThan(0);
expect(row.detail).toBeDefined();
}
expect(data?.rows.map((row) => row.label)).toContain('DB_URL');
expect(data?.rows.map((row) => row.label)).toContain('User');
});
it('sagt nie, wo ein Fehler behandelt wird, weil der Index es nicht sieht', () => {
const errors = block('errors');
expect(errors?.rows.map((row) => row.label)).toEqual(['ValidationError']);
expect(errors?.note).toContain('not visible to the index');
const text = visibleTextOf(model);
expect(text).not.toMatch(/handled at/i);
expect(text).not.toMatch(/caught (?:at|in|by)/i);
});
it('sagt nichts ueber Behandlung, wenn nichts geworfen wird', () => {
const noThrows = {
...CREATE_USER_IR,
throws: { ...CREATE_USER_IR.throws, value: [], evidence: [] },
};
const errors = buildTwinViewModel(noThrows, presentation(2, CORE_FACETS)).sections.find(
(section) => section.name === 'errors',
);
expect(errors?.rows).toHaveLength(0);
expect(errors?.note).toBeUndefined();
});
it('nennt, was im Effekt-Block staende, statt sich als "keine Effekte" zu lesen', () => {
const effects = block('effects');
expect(effects?.rows).toHaveLength(0);
expect(effects?.state).toBe('unsupported');
// Keine Belege, weil CodeAtlas hier nichts behauptet hat.
expect(effects?.factPath).toBe('');
for (const kind of ['routes', 'outbound calls', 'writes']) {
expect(effects?.emptyText).toContain(kind);
}
});
it('rendert Effekte, die die Engine doch aufgezeichnet hat, nach Grenze gruppiert', () => {
const withEffects = {
...CREATE_USER_IR,
externalEffects: {
state: 'known' as const,
value: [
{ kind: 'exposes-route' as const, detail: 'POST /users' },
{ kind: 'io-write' as const, detail: 'users table' },
],
evidence: [],
},
};
const effects = buildTwinViewModel(withEffects, presentation(2, CORE_FACETS)).sections.find(
(section) => section.name === 'effects',
);
expect(effects?.populated).toBe(true);
expect(effects?.rows.map((row) => row.group)).toEqual(['Exposes routes', 'Writes']);
expect(effects?.rows.map((row) => row.label)).toEqual(['POST /users', 'users table']);
expect(effects?.factPath).toBe('externalEffects');
});
it('haelt den Datenblock als Daten lesbar, auch wenn writes nicht aufgezeichnet werden', () => {
// Die 0.9.0-Engine kennt keine write-Relation, also ist die Familie leer
// und unsupported. Wuerde das den Marker der Ueberschrift bestimmen,
// staende "der Index kann das nicht beantworten" ueber einem
// Umgebungswert, den er sehr wohl beantwortet hat.
expect(CREATE_USER_IR.writes.state).toBe('unsupported');
expect(block('state')?.state).toBe('known');
});
});
describe('Facetten subtrahieren', () => {
it('entfernt eine Sektion ganz, wenn ihre Linse aus ist', () => {
const on = buildTwinViewModel(CREATE_USER_IR, presentation(2, CORE_FACETS));
const off = buildTwinViewModel(CREATE_USER_IR, presentation(2, NARROW_FACETS));
expect(sectionNames(on)).toContain('errors');
expect(sectionNames(on)).toContain('state');
expect(sectionNames(off)).not.toContain('errors');
expect(sectionNames(off)).not.toContain('state');
// Die Ueberschriften und ihre Inhalte sind weg. `ValidationError` selbst
// steht weiter da, weil es auch eine Klasse ist, die dieses Symbol
// konstruiert, und Errors auszuschalten ist keine Behauptung, die
// Konstruktion habe nicht stattgefunden.
expect(visibleTextOf(off)).not.toContain('Error paths');
expect(visibleTextOf(off)).not.toContain('State and config');
expect(visibleTextOf(off)).not.toContain('DB_URL');
});
it('behaelt die Aufrufliste, solange eine der beiden Linsen an ist, die sie besitzen', () => {
const logicOnly = buildTwinViewModel(CREATE_USER_IR, presentation(2, [Facet.Logic]));
const callsOnly = buildTwinViewModel(CREATE_USER_IR, presentation(2, [Facet.Calls]));
expect(sectionNames(logicOnly)).toContain('steps');
expect(sectionNames(callsOnly)).toContain('steps');
expect(sectionNames(callsOnly)).not.toContain('purpose');
});
it('rendert Ueberschrift und ehrlichen Satz fuer eine Linse, die der Twin nicht beantwortet', () => {
const model = buildTwinViewModel(CREATE_USER_IR, presentation(2, ALL_FACETS));
const runtime = model.sections.find((section) => section.name === 'runtime');
expect(runtime?.rows[0].label).toContain('not to the twin');
// Kein Beleg anzubieten: CodeAtlas hat hier nichts ueber den Code behauptet.
expect(runtime?.factPath).toBe('');
expect(runtime?.rows[0].factPath).toBe('');
});
it('laesst eine ausgeschaltete Linse weg, statt sie zu erklaeren', () => {
const model = buildTwinViewModel(CREATE_USER_IR, presentation(2, CORE_FACETS));
expect(sectionNames(model)).not.toContain('runtime');
expect(sectionNames(model)).not.toContain('changes');
});
it('laesst die Zahlen weg, die eine Linse aus dem Erzaehl-Absatz entfernt hat', () => {
const withData = visibleTextOf(buildTwinViewModel(CREATE_USER_IR, presentation(0, CORE_FACETS)));
const withoutData = visibleTextOf(
buildTwinViewModel(CREATE_USER_IR, presentation(0, NARROW_FACETS)),
);
expect(withData).toContain('reads 1 value from the environment it runs in');
expect(withoutData).not.toContain('from the environment it runs in');
});
});
describe('Terminologie benennt die Sektionen um und sonst nichts', () => {
const technical = buildTwinViewModel(CREATE_USER_IR, presentation(2, CORE_FACETS, 'technical'));
const plain = buildTwinViewModel(CREATE_USER_IR, presentation(2, CORE_FACETS, 'plain'));
it('tauscht die Ueberschriften', () => {
expect(technical.sections.map((section) => section.title)).toEqual([
'Purpose',
'Steps',
'Called by',
'State and config',
'Error paths',
'Effects',
'Tests',
]);
expect(plain.sections.map((section) => section.title)).toEqual([
'What this is for',
'What it does, in order',
'Who uses it',
'What it reads',
'How it can fail',
'What it touches outside',
'What checks it',
]);
});
it('laesst die Zeilen identisch', () => {
expect(plain.sections.map((section) => section.rows.map((row) => row.label))).toEqual(
technical.sections.map((section) => section.rows.map((row) => row.label)),
);
});
});
/*
* Die Imports-Gruppe im Twin: der zweite Halbsatz des DATA-Blocks.
*
* Auch diese Faelle haben im Referenzprojekt keinen Unit-Test (dort prueft die
* Suite die Gruppe und laesst das Widget sie zeichnen). Geprueft wird genau
* das, was `withImportsSection` entscheidet: welche Linse sie einblendet, in
* welchen Tiefen sie ueberhaupt gezeichnet wird, wo sie steht, und dass sie an
* den Zeilen der IR nichts aendert.
*/
describe('withImportsSection', () => {
const group = buildImportsGroup({
imports: {
entries: [
{ name: 'insert', module: '../repo/db', line: 4, origin: 'source', evidence: [] },
{ name: 'query', module: '../repo/db', line: 4, origin: 'source', evidence: [] },
],
truncated: false,
indexedTargets: ['src/repo/db.ts'],
sourceRead: true,
fileIrs: [CREATE_USER_IR],
},
irs: [CREATE_USER_IR],
uri: CREATE_USER_IR.symbol.uri,
});
const withGroup = (depth: DepthLevel, facets: readonly Facet[] = CORE_FACETS) =>
withImportsSection(
buildTwinViewModel(CREATE_USER_IR, presentation(depth, facets)),
group,
presentation(depth, facets),
);
it('stellt die Gruppe neben die State-Sektion, nie an ihre Stelle', () => {
const names = sectionNames(withGroup(2));
expect(names).toContain('state');
expect(names[names.indexOf('state') + 1]).toBe('imports');
});
it('zeigt sie unter der Data-Linse und nimmt sie mit ihr weg', () => {
expect(sectionNames(withGroup(2))).toContain('imports');
expect(sectionNames(withGroup(2, NARROW_FACETS))).not.toContain('imports');
});
it('zeichnet sie nur dort, wo eine Namensliste eine Antwort ist', () => {
expect(sectionNames(withGroup(0))).not.toContain('imports');
expect(sectionNames(withGroup(1))).not.toContain('imports');
});
it('faltet sie fuer den Senior in das, was eine Aenderung mitbewegt', () => {
const moves = withGroup(3).blocks.find((entry) => entry.name === 'moves');
expect(moves?.rows.some((row) => row.id.startsWith('import-'))).toBe(true);
});
it('faltet sie fuer den Architekten in den Grund, auf dem das Symbol sitzt', () => {
const ground = withGroup(4).blocks.find((entry) => entry.name === 'sits-on');
expect(ground?.rows.some((row) => row.id.startsWith('import-'))).toBe(true);
expect(ground?.weight).toBe('6 entries');
});
it('nennt die Sektion im Vokabular der Praesentation', () => {
const plain = withImportsSection(
buildTwinViewModel(CREATE_USER_IR, presentation(2, CORE_FACETS, 'plain')),
group,
presentation(2, CORE_FACETS, 'plain'),
);
expect(plain.sections.find((section) => section.name === 'imports')?.title)
.toBe('What the file brings in');
});
it('laesst das Modell unberuehrt, solange keine Gruppe da ist', () => {
const model = buildTwinViewModel(CREATE_USER_IR, presentation(2, CORE_FACETS));
expect(withImportsSection(model, undefined, presentation(2, CORE_FACETS))).toBe(model);
});
it('bringt den Wortlaut der Gruppe bis in den sichtbaren Text', () => {
expect(visibleTextOf(withGroup(2))).toContain('1 used in this file');
});
});