mirror of https://github.com/garrytan/gstack.git
78 lines
3.6 KiB
TypeScript
78 lines
3.6 KiB
TypeScript
/**
|
|
* Coverage for #1846 — `browse` CLI must not report "Server failed to start
|
|
* within Ns" when the detached daemon actually came up healthy a moment later.
|
|
*
|
|
* The spawned server is `detached: true` + `.unref()`'d, so it keeps booting
|
|
* independently of the CLI's poll loop. On a loaded machine (the issue repro is
|
|
* Windows under load) the loop's budget can elapse in the gap between its last
|
|
* health tick and the daemon becoming ready — the very next `browse status`
|
|
* then shows a healthy, listening server. #1732 only widened the budget; the
|
|
* throw site itself still fired on timeout regardless of real health.
|
|
*
|
|
* Two invariants are defended here:
|
|
* 1. `startServer` does a final readState()+isServerHealthy() re-check before
|
|
* the timeout throw (structural — removes the false negative at any budget).
|
|
* 2. The startup budget is env-overridable via BROWSE_START_TIMEOUT, matching
|
|
* the BROWSE_* tunable convention (BROWSE_PORT, BROWSE_IDLE_TIMEOUT, ...).
|
|
*
|
|
* (1) is a static source invariant (live spawn cycles belong in the e2e tier);
|
|
* (2) is exercised behaviorally against the exported pure helper.
|
|
*/
|
|
import { describe, expect, test } from 'bun:test';
|
|
import * as fs from 'node:fs';
|
|
import * as path from 'node:path';
|
|
import { resolveStartTimeout } from '../src/cli';
|
|
|
|
const CLI = path.join(import.meta.dir, '..', 'src', 'cli.ts');
|
|
const read = (): string => fs.readFileSync(CLI, 'utf-8');
|
|
|
|
describe('#1846 startServer false-negative on a late-healthy detached daemon', () => {
|
|
test('a final health re-check sits between the poll loop and the timeout throw', () => {
|
|
const src = read();
|
|
const throwIdx = src.indexOf('Server failed to start within');
|
|
expect(throwIdx).toBeGreaterThan(-1);
|
|
|
|
// The startServer poll loop ends at its `await Bun.sleep(100)`; the final
|
|
// re-check must live AFTER that loop and BEFORE the timeout throw.
|
|
const loopEnd = src.lastIndexOf('await Bun.sleep(100)', throwIdx);
|
|
expect(loopEnd).toBeGreaterThan(-1);
|
|
const between = src.slice(loopEnd, throwIdx);
|
|
|
|
// It must re-read state and re-probe health, then be able to return — i.e.
|
|
// a genuine recovery path, not just a comment.
|
|
expect(between).toContain('readState()');
|
|
expect(between).toMatch(/isServerHealthy\([^)]*\)/);
|
|
expect(between).toMatch(/return\s+\w+;/);
|
|
});
|
|
|
|
test('the re-check returns the recovered state rather than swallowing it', () => {
|
|
const src = read();
|
|
// Guard against a refactor that probes health but forgets to return the
|
|
// state (which would re-introduce the false negative).
|
|
expect(src).toMatch(/if\s*\([^)]*await\s+isServerHealthy\([^)]*\)\)\s*\{\s*return\s+\w+;/);
|
|
});
|
|
});
|
|
|
|
describe('#1846 BROWSE_START_TIMEOUT env override (resolveStartTimeout)', () => {
|
|
const platformDefault = resolveStartTimeout({} as NodeJS.ProcessEnv);
|
|
|
|
test('platform default is a positive millisecond budget when unset', () => {
|
|
expect(platformDefault).toBeGreaterThan(0);
|
|
});
|
|
|
|
test('honors a positive BROWSE_START_TIMEOUT override', () => {
|
|
expect(resolveStartTimeout({ BROWSE_START_TIMEOUT: '42000' } as NodeJS.ProcessEnv)).toBe(42000);
|
|
});
|
|
|
|
test('falls back to the platform default for non-positive / unparseable values', () => {
|
|
for (const bad of ['0', '-5', 'abc', '', ' ']) {
|
|
expect(resolveStartTimeout({ BROWSE_START_TIMEOUT: bad } as NodeJS.ProcessEnv)).toBe(platformDefault);
|
|
}
|
|
});
|
|
|
|
test('MAX_START_WAIT is wired through resolveStartTimeout (no stray hardcoded constant)', () => {
|
|
const src = read();
|
|
expect(src).toMatch(/const\s+MAX_START_WAIT\s*=\s*resolveStartTimeout\(\)/);
|
|
});
|
|
});
|