Beautiful, AI-native markdown IDE and LLM wiki
TypeScript 2nd-brainagent-skillsclaudecodexcompany-braindocsknowledge-knowledge-baseknowledge-managementllmllm-wikillm-wiki-karpathymarkdownmarkdown-editormdmdxnotespkmsecond-brainskills
Declare layout bounds for smoke dimension polls (#5198)
Nick Gomez5eb1b59f88d1
diff --git a/packages/desktop/tests/smoke/_helpers/dock-height-settlement.uncached.test.ts b/packages/desktop/tests/smoke/_helpers/dock-height-settlement.uncached.test.tsnew file mode 100644index 000000000..9153559f0--- /dev/null+++ b/packages/desktop/tests/smoke/_helpers/dock-height-settlement.uncached.test.ts@@ -0,0 +1,170 @@+import { readFileSync } from 'node:fs';+import { createRequire } from 'node:module';+import { fileURLToPath } from 'node:url';+import { stripVTControlCharacters } from 'node:util';+import { compileFunction, runInNewContext } from 'node:vm';+import { expect as playwrightExpect } from '@playwright/test';+import { afterEach, expect, test, vi } from 'vitest';+import type * as TypeScript from '../../../../../node_modules/typescript';+import * as settledReading from './settled-reading';++const ts: typeof TypeScript = createRequire(+ fileURLToPath(new URL('../../../../../package.json', import.meta.url)),+)('typescript');++const heightBefore = 300;+const heightAfter = heightBefore + 160;+const reopenedHeightTolerance = 40;++function currentDockHeightWait(label: string): string {+ const path = fileURLToPath(new URL('../terminal-dock.e2e.ts', import.meta.url));+ const source = readFileSync(path, 'utf8');+ const parsed = ts.createSourceFile(path, source, ts.ScriptTarget.Latest, true);+ let dockTest: TypeScript.CallExpression | undefined;+ const visit = (node: TypeScript.Node): void => {+ if (+ ts.isCallExpression(node) &&+ ts.isIdentifier(node.expression) &&+ node.expression.text === 'test' &&+ ts.isStringLiteral(node.arguments[0]) &&+ node.arguments[0].text === 'QA-023 panel height persists across reopen'+ ) {+ dockTest = node;+ }+ ts.forEachChild(node, visit);+ };+ visit(parsed);+ const callback = dockTest?.arguments[1];+ if (!callback || !ts.isArrowFunction(callback) || !ts.isBlock(callback.body)) {+ throw new Error('dock height smoke test is unavailable');+ }+ const pollsReading = (node: TypeScript.Node): boolean =>+ (ts.isCallExpression(node) &&+ ts.isIdentifier(node.expression) &&+ node.expression.text === 'pollSettledReading' &&+ ts.isObjectLiteralExpression(node.arguments[1]) &&+ node.arguments[1].properties.some(+ (property) =>+ ts.isPropertyAssignment(property) &&+ ts.isIdentifier(property.name) &&+ property.name.text === 'reading' &&+ ts.isStringLiteral(property.initializer) &&+ property.initializer.text === label,+ )) ||+ ts.forEachChild(node, (child) => pollsReading(child) || undefined) === true;+ const waits = callback.body.statements.filter(+ (statement) =>+ ts.isExpressionStatement(statement) &&+ ts.isAwaitExpression(statement.expression) &&+ pollsReading(statement.expression),+ );+ if (waits.length !== 1) {+ throw new Error(+ `dock height smoke test has ${waits.length} settled "${label}" waits; expected exactly one`,+ );+ }+ return waits[0].getText(parsed);+}++function runCurrentDockWait(label: string, panelHeight: number, persistedHeight: number) {+ const source = currentDockHeightWait(label);+ const path = fileURLToPath(new URL('../terminal-dock.e2e.ts', import.meta.url));+ let releaseRead: (() => void) | undefined;+ let markReadStarted: (() => void) | undefined;+ const readStarted = new Promise<void>((resolve) => {+ markReadStarted = resolve;+ });+ const reading = new Promise<void>((resolve) => {+ releaseRead = resolve;+ });+ const panel = {+ async evaluate(callback: (element: unknown) => number): Promise<number> {+ markReadStarted?.();+ await reading;+ return runInNewContext(`(${callback.toString()})(element)`, {+ element: { getBoundingClientRect: () => ({ height: panelHeight }) },+ }) as number;+ },+ };+ const page = {+ async evaluate(callback: () => number): Promise<number> {+ markReadStarted?.();+ await reading;+ return runInNewContext(`(${callback.toString()})()`, {+ localStorage: {+ getItem: (key: string) =>+ key === 'ok-terminal-height-v1' ? String(persistedHeight) : null,+ },+ }) as number;+ },+ };+ const bindings = {+ ...settledReading,+ expect: playwrightExpect,+ panel,+ page,+ heightBefore,+ heightAfter,+ };+ const executable = ts.transpileModule(`return async () => { ${source} }`, {+ compilerOptions: { target: ts.ScriptTarget.ESNext, module: ts.ModuleKind.ESNext },+ }).outputText;+ const runWait = compileFunction(executable, Object.keys(bindings), { filename: path })(+ ...Object.values(bindings),+ ) as () => Promise<void>;+ const result = runWait().then(+ () => 'settled',+ (error: unknown) => error,+ );+ return { result, readStarted, releaseRead };+}++afterEach(() => vi.useRealTimers());++test.each(['height', 'persisted height', 'reopened height difference'])(+ '%s settles when its dimension read completes within the layout budget',+ async (label) => {+ vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'performance'] });+ const { result, readStarted, releaseRead } = runCurrentDockWait(+ label,+ heightAfter,+ heightAfter,+ );+ await readStarted;+ await vi.advanceTimersByTimeAsync(settledReading.RAIL_LAYOUT_SETTLE_TIMEOUT_MS - 1);+ releaseRead?.();++ expect(await result).toBe('settled');+ },+);++test.each([+ ['height', heightBefore, heightAfter, 'toBeGreaterThan', heightBefore],+ ['persisted height', heightAfter, heightBefore, 'toBeGreaterThan', heightBefore],+ [+ 'reopened height difference',+ heightAfter + reopenedHeightTolerance,+ heightAfter,+ 'toBeLessThan',+ reopenedHeightTolerance,+ ],+] as const)(+ '%s rejects a completed reading exactly on its strict boundary',+ async (label, panelHeight, persistedHeight, matcher, boundary) => {+ vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'performance'] });+ const { result, readStarted, releaseRead } = runCurrentDockWait(+ label,+ panelHeight,+ persistedHeight,+ );+ releaseRead?.();+ await readStarted;+ await vi.advanceTimersByTimeAsync(settledReading.RAIL_LAYOUT_SETTLE_TIMEOUT_MS + 1);++ const outcome = await result;+ expect(outcome).toBeInstanceOf(Error);+ const message = stripVTControlCharacters((outcome as Error).message);+ expect(message).toContain(`expect(received).${matcher}(expected)`);+ expect(message).toMatch(new RegExp(`^Received:\\s+${boundary}$`, 'm'));+ },+);diff --git a/packages/desktop/tests/smoke/_helpers/polled-reading.test.ts b/packages/desktop/tests/smoke/_helpers/polled-reading.test.tsnew file mode 100644index 000000000..da8ab823d--- /dev/null+++ b/packages/desktop/tests/smoke/_helpers/polled-reading.test.ts@@ -0,0 +1,75 @@+import { afterEach, expect, test, vi } from 'vitest';+import { pollSettledReading, RAIL_LAYOUT_SETTLE_TIMEOUT_MS } from './settled-reading';++afterEach(() => vi.useRealTimers());++test.each([+ ['zero', 0],+ ['negative', -1],+ ['not a number', Number.NaN],+ ['infinite', Number.POSITIVE_INFINITY],+] as const)('a %s deadline cannot disable the poll bound', (_name, timeout) => {+ expect(() =>+ pollSettledReading(() => Promise.resolve(1), {+ reading: 'dimension',+ of: 'test surface',+ timeout,+ }),+ ).toThrow('positive, finite timeout');+});++test('a reading completed after its declared bound cannot turn the verdict into success', async () => {+ vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'performance'] });+ const started = Promise.withResolvers<void>();+ const reading = Promise.withResolvers<string>();+ const result = pollSettledReading(+ () => {+ started.resolve();+ return reading.promise;+ },+ {+ reading: 'dimension',+ of: 'test surface',+ timeout: RAIL_LAYOUT_SETTLE_TIMEOUT_MS,+ },+ )+ .toBe('ready')+ .then(+ () => 'settled',+ (error: unknown) => error,+ );+ await started.promise;+ await vi.advanceTimersByTimeAsync(RAIL_LAYOUT_SETTLE_TIMEOUT_MS + 1);+ reading.resolve('ready');+ await vi.runAllTimersAsync();++ expect(await result).toBeInstanceOf(Error);+});++test('a synchronous reader failure is preserved even if another attempt could succeed', async () => {+ vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'performance'] });+ const failure = new Error('dimension reader failed');+ let failed = false;+ const result = pollSettledReading(+ () => {+ if (!failed) {+ failed = true;+ throw failure;+ }+ return Promise.resolve(1);+ },+ {+ reading: 'dimension',+ of: 'test surface',+ timeout: RAIL_LAYOUT_SETTLE_TIMEOUT_MS,+ },+ )+ .toBe(1)+ .then(+ () => 'settled',+ (error: unknown) => error,+ );+ await vi.runAllTimersAsync();++ expect(await result).toMatchObject({ message: expect.stringContaining(failure.message) });+});diff --git a/packages/desktop/tests/smoke/_helpers/settled-reading.ts b/packages/desktop/tests/smoke/_helpers/settled-reading.tsindex 72cb571b9..637ae0fbb 100644--- a/packages/desktop/tests/smoke/_helpers/settled-reading.ts+++ b/packages/desktop/tests/smoke/_helpers/settled-reading.ts@@ -49,6 +49,17 @@ export type SettleBound =export type SettledReadingOptions = { reading: string; of: string } & SettleBound;+export function pollSettledReading<T>(+ read: () => Promise<T>,+ options: Extract<SettledReadingOptions, { timeout: number }>,+): ReturnType<typeof expect.poll<T>> {+ requirePositiveTimeout('pollSettledReading', options.timeout);+ return expect.poll(read, {+ timeout: options.timeout,+ message: `${options.reading} of ${options.of}`,+ });+}+type SettleAttempt =| { readonly kind: 'none' }| { readonly kind: 'read' }diff --git a/packages/desktop/tests/smoke/_helpers/window-size-settlement.uncached.test.ts b/packages/desktop/tests/smoke/_helpers/window-size-settlement.uncached.test.tsnew file mode 100644index 000000000..e267f5f0a--- /dev/null+++ b/packages/desktop/tests/smoke/_helpers/window-size-settlement.uncached.test.ts@@ -0,0 +1,132 @@+import { readFileSync } from 'node:fs';+import { createRequire } from 'node:module';+import { fileURLToPath } from 'node:url';+import { stripVTControlCharacters } from 'node:util';+import { compileFunction, runInNewContext } from 'node:vm';+import { expect as playwrightExpect } from '@playwright/test';+import { afterEach, expect, test, vi } from 'vitest';+import type * as TypeScript from '../../../../../node_modules/typescript';+import * as settledReading from './settled-reading';++const ts: typeof TypeScript = createRequire(+ fileURLToPath(new URL('../../../../../package.json', import.meta.url)),+)('typescript');++type Size = { width: number; height: number };+type Page = { evaluate(callback: () => number): Promise<number> };+type App = {+ browserWindow(page: Page): Promise<{+ evaluate(callback: (handle: unknown, size: Size) => void, size: Size): Promise<void>;+ }>;+};+type SetWindowSize = (app: App, page: Page, width: number, height: number) => Promise<void>;++function currentSetWindowSize(): SetWindowSize {+ const path = fileURLToPath(new URL('../terminal-process-restart.e2e.ts', import.meta.url));+ const source = readFileSync(path, 'utf8');+ const parsed = ts.createSourceFile(path, source, ts.ScriptTarget.Latest, true);+ const declaration = parsed.statements.find(+ (statement) => ts.isFunctionDeclaration(statement) && statement.name?.text === 'setWindowSize',+ );+ if (!declaration) throw new Error('setWindowSize is unavailable for the smoke contract');+ const executable = ts.transpileModule(`return (${declaration.getText(parsed)});`, {+ compilerOptions: { target: ts.ScriptTarget.ESNext, module: ts.ModuleKind.ESNext },+ }).outputText;+ const bindings = { ...settledReading, expect: playwrightExpect };+ return compileFunction(executable, Object.keys(bindings), { filename: path })(+ ...Object.values(bindings),+ ) as SetWindowSize;+}++const requestedWidth = 1900;+const requestedHeight = 900;++function runCurrentWindowSize(readWidth: () => Promise<number>) {+ const setWindowSize = currentSetWindowSize();+ const readStarted = Promise.withResolvers<void>();+ const reading = Promise.withResolvers<void>();+ const page: Page = {+ async evaluate(callback) {+ readStarted.resolve();+ await reading.promise;+ const innerWidth = await readWidth();+ return runInNewContext(`(${callback.toString()})()`, { window: { innerWidth } }) as number;+ },+ };+ const app: App = {+ async browserWindow(receivedPage) {+ if (receivedPage !== page) throw new Error('window lookup used another page');+ return {+ async evaluate(callback, size) {+ callback({ setSize: () => undefined }, size);+ },+ };+ },+ };+ const result = setWindowSize(app, page, requestedWidth, requestedHeight).then(+ () => 'settled',+ (error: unknown) => error,+ );+ return { result, readStarted: readStarted.promise, releaseRead: reading.resolve };+}++afterEach(() => vi.useRealTimers());++test('a requested editor width settles when the renderer read completes within the layout budget', async () => {+ vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'performance'] });+ const { result, readStarted, releaseRead } = runCurrentWindowSize(() =>+ Promise.resolve(requestedWidth),+ );+ await readStarted;+ await vi.advanceTimersByTimeAsync(settledReading.RAIL_LAYOUT_SETTLE_TIMEOUT_MS - 1);+ releaseRead();++ expect(await result).toBe('settled');+});++test('the editor width at the requested minimum is accepted', async () => {+ vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'performance'] });+ const { result, readStarted, releaseRead } = runCurrentWindowSize(() =>+ Promise.resolve(requestedWidth - 100),+ );+ releaseRead();+ await readStarted;+ await vi.advanceTimersByTimeAsync(settledReading.RAIL_LAYOUT_SETTLE_TIMEOUT_MS + 1);++ expect(await result).toBe('settled');+});++test('an editor width below the requested minimum is rejected', async () => {+ vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'performance'] });+ const belowMinimumWidth = requestedWidth - 100 - 1;+ const { result, readStarted, releaseRead } = runCurrentWindowSize(() =>+ Promise.resolve(belowMinimumWidth),+ );+ releaseRead();+ await readStarted;+ await vi.advanceTimersByTimeAsync(settledReading.RAIL_LAYOUT_SETTLE_TIMEOUT_MS + 1);++ const outcome = await result;+ expect(outcome).toBeInstanceOf(Error);+ const message = stripVTControlCharacters((outcome as Error).message);+ expect(message).toContain('expect(received).toBeGreaterThanOrEqual(expected)');+ expect(message).toMatch(new RegExp(`^Received:\\s+${belowMinimumWidth}$`, 'm'));+});++test('a rejected renderer reading remains a failure when a later reading could succeed', async () => {+ vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'performance'] });+ const failure = new Error('renderer reading failed');+ let failed = false;+ const { result, readStarted, releaseRead } = runCurrentWindowSize(() => {+ if (!failed) {+ failed = true;+ return Promise.reject(failure);+ }+ return Promise.resolve(requestedWidth);+ });+ releaseRead();+ await readStarted;+ await vi.runAllTimersAsync();++ expect(await result).toMatchObject({ message: expect.stringContaining(failure.message) });+});diff --git a/packages/desktop/tests/smoke/terminal-dock.e2e.ts b/packages/desktop/tests/smoke/terminal-dock.e2e.tsindex 7aff169f2..11b8e66a5 100644--- a/packages/desktop/tests/smoke/terminal-dock.e2e.ts+++ b/packages/desktop/tests/smoke/terminal-dock.e2e.ts@@ -29,6 +29,7 @@ import {import { expectCollapsedRailColumn } from './_helpers/rail-column';import {expectSettledReading,+ pollSettledReading,RAIL_LAYOUT_SETTLE_TIMEOUT_MS,settleBudget,} from './_helpers/settled-reading';@@ -936,26 +937,38 @@ test.describe('Docked terminal — live Electron', () => {await page.mouse.move(box.x + box.width / 2, box.y - 160, { steps: 12 });await page.mouse.up();- await expect- .poll(() => panel.evaluate((el) => el.getBoundingClientRect().height))- .toBeGreaterThan(heightBefore);+ await pollSettledReading(() => panel.evaluate((el) => el.getBoundingClientRect().height), {+ reading: 'height',+ of: '#terminal-dock-panel after resize',+ timeout: 10_000 satisfies typeof RAIL_LAYOUT_SETTLE_TIMEOUT_MS,+ }).toBeGreaterThan(heightBefore);const heightAfter = await panel.evaluate((el) => el.getBoundingClientRect().height);- await expect- .poll(() => page.evaluate(() => Number(localStorage.getItem('ok-terminal-height-v1') ?? 0)))- .toBeGreaterThan(heightBefore);+ await pollSettledReading(+ () => page.evaluate(() => Number(localStorage.getItem('ok-terminal-height-v1') ?? 0)),+ {+ reading: 'persisted height',+ of: 'bottom terminal',+ timeout: 10_000 satisfies typeof RAIL_LAYOUT_SETTLE_TIMEOUT_MS,+ },+ ).toBeGreaterThan(heightBefore);await clickViewTerminalItem(app, page);await expect(panel).toHaveAttribute('inert', '', { timeout: 10_000 });await clickViewTerminalItem(app, page);await expect(terminalSection(page)).toBeVisible({ timeout: 10_000 });- await expect- .poll(async () => {+ await pollSettledReading(+ async () => {const heightReopen = await panel.evaluate((el) => el.getBoundingClientRect().height);return Math.abs(heightReopen - heightAfter);- })- .toBeLessThan(40);+ },+ {+ reading: 'reopened height difference',+ of: '#terminal-dock-panel',+ timeout: 10_000 satisfies typeof RAIL_LAYOUT_SETTLE_TIMEOUT_MS,+ },+ ).toBeLessThan(40);});test('QA-015/032 shell exit shows restart; banner hidden on exit', async ({diff --git a/packages/desktop/tests/smoke/terminal-process-restart.e2e.ts b/packages/desktop/tests/smoke/terminal-process-restart.e2e.tsindex 631cb4af3..01d8c3787 100644--- a/packages/desktop/tests/smoke/terminal-process-restart.e2e.ts+++ b/packages/desktop/tests/smoke/terminal-process-restart.e2e.ts@@ -24,6 +24,7 @@ import {import { readRailColumnWidth } from './_helpers/rail-column';import {expectSettledReading,+ pollSettledReading,RAIL_LAYOUT_SETTLE_TIMEOUT_MS,settleBudget,} from './_helpers/settled-reading';@@ -119,9 +120,11 @@ async function setWindowSize(},{ width, height },);- await expect- .poll(() => page.evaluate(() => window.innerWidth))- .toBeGreaterThanOrEqual(width - 100);+ await pollSettledReading(() => page.evaluate(() => window.innerWidth), {+ reading: 'viewport width',+ of: 'editor window',+ timeout: 10_000 satisfies typeof RAIL_LAYOUT_SETTLE_TIMEOUT_MS,+ }).toBeGreaterThanOrEqual(width - 100);}async function dispatchRendererMenuAction(