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 eigene Tooltip in jsdom: wann er da ist, wo er steht und wie man ihn
* wieder los wird.
*
* Was hier NICHT geprueft wird, ist seine Lage in Pixeln: jsdom hat kein
* Layout, jedes Rechteck ist null mal null, und eine Rechnung ueber Nullen
* bewiese nichts. Die Rechnung selbst steht ohne DOM in tooltip-model.test.ts,
* und dass sie in einem echten Fenster nichts verdeckt, misst der Beweislauf
* (tools/smoke-w8b.mjs, tooltipCoversNothing).
*
* Hier steht die andere Haelfte, und sie ist die, die ein Browserlauf schlecht
* sieht: dass es den Kasten UEBERHAUPT nur gibt, wenn er etwas zu sagen hat,
* dass die Tastatur ihn oeffnet, dass Escape ihn schliesst, und dass der
* Ausloeser seine eigenen Rueckrufe behaelt.
*/
import { act } from 'react';
import { createRoot, type Root } from 'react-dom/client';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import Hint from './Hint';
let container: HTMLDivElement;
let root: Root;
beforeEach(() => {
(globalThis as unknown as Record<string, unknown>).IS_REACT_ACT_ENVIRONMENT = true;
container = document.createElement('div');
document.body.appendChild(container);
root = createRoot(container);
});
afterEach(async () => {
await act(async () => {
root.unmount();
});
container.remove();
});
const tooltip = (): Element | null => document.body.querySelector('[data-testid="atlas-hint"]');
const trigger = (): HTMLButtonElement =>
container.querySelector('button') as HTMLButtonElement;
async function render(node: React.ReactElement): Promise<void> {
await act(async () => {
root.render(node);
});
}
describe('Hint', () => {
it('zeichnet keinen Kasten, solange niemand hinsieht', async () => {
await render(<Hint name="probe" text="what this does"><button type="button">go</button></Hint>);
expect(tooltip()).toBeNull();
expect(trigger().getAttribute('data-hint')).toBe('what this does');
expect(trigger().hasAttribute('title')).toBe(false);
});
it('oeffnet bei Hover und schliesst wieder', async () => {
await render(<Hint name="probe" text="what this does"><button type="button">go</button></Hint>);
await act(async () => {
trigger().dispatchEvent(new MouseEvent('mouseover', { bubbles: true }));
});
expect(tooltip()?.textContent).toBe('what this does');
expect(tooltip()?.getAttribute('role')).toBe('tooltip');
await act(async () => {
trigger().dispatchEvent(new MouseEvent('mouseout', { bubbles: true }));
});
expect(tooltip()).toBeNull();
});
/*
* Die Zusicherung, die dem Contract wichtiger ist als jede andere: ein
* Tooltip, den nur die Maus oeffnet, ist keiner. Diese Oberflaeche ist an
* der Tastatur entworfen (PLAN Abschnitt 4).
*/
it('oeffnet bei Fokus und traegt dann aria-describedby am Ausloeser', async () => {
await render(<Hint name="probe" text="what this does"><button type="button">go</button></Hint>);
await act(async () => {
trigger().focus();
});
const box = tooltip();
expect(box).not.toBeNull();
expect(trigger().getAttribute('aria-describedby')).toBe(box?.getAttribute('id'));
});
it('schliesst mit Escape', async () => {
await render(<Hint name="probe" text="what this does"><button type="button">go</button></Hint>);
await act(async () => {
trigger().focus();
});
expect(tooltip()).not.toBeNull();
await act(async () => {
window.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
});
expect(tooltip()).toBeNull();
});
/*
* Ein `title`, der nur den sichtbaren Text wiederholt, faellt in W8b
* ersatzlos weg, und die Aufrufer geben dafuer nichts oder einen leeren
* Satz weiter. Der Kasten muss den Ausloeser dann unveraendert
* durchreichen: eine Huelle, die nichts sagt, waere ein Element mehr im
* Baum, das jede Messung mitzaehlt.
*/
it('reicht den Ausloeser unveraendert durch, wenn es nichts zu sagen gibt', async () => {
await render(<Hint name="probe" text=""><button type="button">go</button></Hint>);
expect(trigger().hasAttribute('data-hint')).toBe(false);
await act(async () => {
trigger().dispatchEvent(new MouseEvent('mouseover', { bubbles: true }));
});
expect(tooltip()).toBeNull();
});
it('laesst dem Ausloeser seine eigenen Rueckrufe', async () => {
const onClick = vi.fn();
const onFocus = vi.fn();
await render(
<Hint name="probe" text="what this does">
<button type="button" onClick={onClick} onFocus={onFocus}>go</button>
</Hint>,
);
await act(async () => {
trigger().focus();
});
expect(onFocus).toHaveBeenCalledTimes(1);
expect(tooltip()).not.toBeNull();
await act(async () => {
trigger().click();
});
expect(onClick).toHaveBeenCalledTimes(1);
});
/*
* Ein Klick schliesst ihn, und der Grund steht an der Stelle, an der es
* gemacht wird (src/ui/tooltip/Hint.tsx): der Satz sagt, was ein Knopf TUN
* WIRD, und nach dem Druecken ist er die Beschreibung von etwas, das schon
* passiert ist. An den Schaltern dieser Oberflaeche ist er dann obendrein
* falsch, weil ihre Beschriftung mit dem Zustand kippt.
*/
/*
* Handtest 2026-10-04 (G3): der Kasten an "Expand +1" stand rechts neben
* dem Knopf und ragte in den Kopf der Seite, obwohl unter ihm Platz war.
* Geschuetzt waren die Eingabefelder der zugeklappten Menues daneben
* ("Path to…", "Edge types"): ihr Inhalt ist nicht gezeichnet, hatte im
* Browser aber weiter einen Kasten. Geschuetzt ist nur, was zu sehen ist.
*/
it('weicht keinem Feld aus, das in einem zugeklappten details gar nicht gezeichnet ist', async () => {
const rect = (x: number, y: number, width: number, height: number) => () =>
({ x, y, width, height, left: x, top: y, right: x + width, bottom: y + height, toJSON: () => ({}) }) as DOMRect;
const size = vi.spyOn(HTMLElement.prototype, 'offsetWidth', 'get').mockImplementation(function (this: HTMLElement) {
return this.dataset.testid === 'atlas-hint' ? 200 : 0;
});
const height = vi.spyOn(HTMLElement.prototype, 'offsetHeight', 'get').mockImplementation(function (this: HTMLElement) {
return this.dataset.testid === 'atlas-hint' ? 40 : 0;
});
await render(
<div>
<Hint name="probe" text="what this does"><button type="button">go</button></Hint>
<details><summary>menu</summary><input aria-label="field in the menu" /></details>
</div>,
);
trigger().getBoundingClientRect = rect(100, 100, 80, 24);
// Right under the trigger, where the box goes first: the field of the closed menu.
const field = container.querySelector('input')!;
field.getBoundingClientRect = rect(100, 130, 300, 30);
const hover = async () => {
await act(async () => { trigger().dispatchEvent(new MouseEvent('mouseover', { bubbles: true })); });
const side = tooltip()?.getAttribute('data-side');
await act(async () => { trigger().dispatchEvent(new MouseEvent('mouseout', { bubbles: true })); });
return side;
};
expect(await hover()).toBe('below');
// Open, the field is drawn and protected again: the box goes above.
container.querySelector('details')!.open = true;
expect(await hover()).toBe('above');
size.mockRestore(); height.mockRestore();
});
it('schliesst sich, sobald der Ausloeser gedrueckt wurde', async () => {
await render(<Hint name="probe" text="what this does"><button type="button">go</button></Hint>);
await act(async () => {
trigger().dispatchEvent(new MouseEvent('mouseover', { bubbles: true }));
});
expect(tooltip()).not.toBeNull();
await act(async () => {
trigger().click();
});
expect(tooltip()).toBeNull();
});
/*
* Der Befund W10-1: ein Ausloeser, der NICHTS tut ausser diesen Satz zu
* tragen, ist auf einem Zeigegeraet ohne Hover unerreichbar, und als
* `<button>` verspricht er ausserdem eine Handlung, die es nicht gibt. Wer
* den Griff nimmt, bekommt den Klick: einmal haelt fest, einmal laesst los.
*/
describe('der Klick-Griff', () => {
const held = (): string | null => trigger().getAttribute('data-hint-held');
async function renderHeld(): Promise<void> {
await render(
<Hint name="probe" text="where this comes from">
{(hold) => (
<button type="button" aria-expanded={hold.held} onClick={hold.toggle}>?</button>
)}
</Hint>,
);
}
it('haelt den Kasten fest, ohne dass jemand hovert', async () => {
await renderHeld();
expect(tooltip()).toBeNull();
await act(async () => {
trigger().click();
});
expect(tooltip()?.textContent).toBe('where this comes from');
expect(held()).toBe('true');
expect(trigger().getAttribute('aria-expanded')).toBe('true');
});
it('bleibt stehen, wenn der Zeiger weiterzieht', async () => {
await renderHeld();
await act(async () => {
trigger().dispatchEvent(new MouseEvent('mouseover', { bubbles: true }));
trigger().click();
});
await act(async () => {
trigger().dispatchEvent(new MouseEvent('mouseout', { bubbles: true }));
});
expect(tooltip()).not.toBeNull();
});
it('laesst ihn beim zweiten Klick wieder los', async () => {
await renderHeld();
await act(async () => {
trigger().dispatchEvent(new MouseEvent('mouseover', { bubbles: true }));
trigger().click();
});
expect(tooltip()).not.toBeNull();
await act(async () => {
trigger().click();
});
expect(tooltip()).toBeNull();
expect(held()).toBe('false');
});
it('laesst ihn mit Escape los', async () => {
await renderHeld();
await act(async () => {
trigger().click();
});
expect(tooltip()).not.toBeNull();
await act(async () => {
window.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
});
expect(tooltip()).toBeNull();
expect(held()).toBe('false');
});
/*
* Wer weiterarbeitet, meint dasselbe wie Escape. Ohne diese Zusicherung
* bliebe ein festgehaltener Kasten ueber der Stelle stehen, an der es
* gerade weitergeht.
*/
it('laesst ihn los, wenn der naechste Griff woanders zupackt', async () => {
await renderHeld();
await act(async () => {
trigger().click();
});
expect(tooltip()).not.toBeNull();
await act(async () => {
document.body.dispatchEvent(new MouseEvent('pointerdown', { bubbles: true }));
});
expect(tooltip()).toBeNull();
});
});
});