Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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(