Garry's Opinionated OpenClaw/Hermes Agent Brain
TypeScript
/**
* Pure-function unit tests for `gbrain status` orchestrator helpers.
*
* Hermetic — no PGLite, no DB. Drives the exported helpers (parseSectionFlag,
* runStatus with engine=null in thin-client-disabled mode) and asserts:
* - JSON envelope shape stability (schema_version: 1)
* - --section filter validation (unknown → exit 2)
* - exit code policy (0 success/degraded, 1 snapshot failure, 2 usage)
* - thin-client local-only-N/A render for Locks/Workers/Queue/Autopilot
* (we exercise this via a stubbed cfg that mimics thin-client mode)
*
* The E2E test at test/e2e/status-pglite.test.ts covers the full PGLite +
* fake-minion_jobs + fake-supervisor-audit path.
*/
import { describe, test, expect } from 'bun:test';
import {
parseSectionFlag,
parseDeadlineFlag,
withSectionDeadline,
runStatus,
FAST_DEADLINE_MS,
} from '../src/commands/status.ts';
describe('parseDeadlineFlag (#1984)', () => {
test('no flag → undefined (no budget)', () => {
expect(parseDeadlineFlag([])).toBeUndefined();
expect(parseDeadlineFlag(['--json'])).toBeUndefined();
});
test('--fast applies the preset budget', () => {
expect(parseDeadlineFlag(['--fast'])).toBe(FAST_DEADLINE_MS);
});
test('--deadline-ms in both forms', () => {
expect(parseDeadlineFlag(['--deadline-ms', '500'])).toBe(500);
expect(parseDeadlineFlag(['--deadline-ms=750'])).toBe(750);
});
test('explicit --deadline-ms wins over --fast', () => {
expect(parseDeadlineFlag(['--fast', '--deadline-ms=100'])).toBe(100);
});
test('non-positive / non-numeric → usage_error', () => {
expect(parseDeadlineFlag(['--deadline-ms', '0'])).toBe('usage_error');
expect(parseDeadlineFlag(['--deadline-ms', '-5'])).toBe('usage_error');
expect(parseDeadlineFlag(['--deadline-ms', 'soon'])).toBe('usage_error');
});
test('bare --deadline-ms with no value → usage_error (not a silent no-budget fallthrough)', () => {
expect(parseDeadlineFlag(['--deadline-ms'])).toBe('usage_error');
expect(parseDeadlineFlag(['--fast', '--deadline-ms'])).toBe('usage_error');
});
});
describe('withSectionDeadline (#1984)', () => {
test('resolves the value when it beats the budget', async () => {
let timedOut = false;
const v = await withSectionDeadline(Promise.resolve(42), 1000, () => { timedOut = true; });
expect(v).toBe(42);
expect(timedOut).toBe(false);
});
test('returns undefined + fires onTimeout when the budget elapses', async () => {
let timedOut = false;
const v = await withSectionDeadline(new Promise<number>(() => {}), 10, () => { timedOut = true; });
expect(v).toBeUndefined();
expect(timedOut).toBe(true);
});
test('no budget (undefined/<=0) awaits the promise as-is', async () => {
expect(await withSectionDeadline(Promise.resolve('x'), undefined, () => {})).toBe('x');
expect(await withSectionDeadline(Promise.resolve('y'), 0, () => {})).toBe('y');
});
});
describe('parseSectionFlag', () => {
test('no --section flag → undefined (all sections)', () => {
expect(parseSectionFlag([])).toBeUndefined();
expect(parseSectionFlag(['--json'])).toBeUndefined();
});
test('--section <name> form returns the set', () => {
const r = parseSectionFlag(['--section', 'sync']);
expect(r).toBeInstanceOf(Set);
expect((r as Set<string>).has('sync')).toBe(true);
});
test('--section=<name> form returns the set', () => {
const r = parseSectionFlag(['--section=cycle']);
expect(r).toBeInstanceOf(Set);
expect((r as Set<string>).has('cycle')).toBe(true);
});
test('unknown section returns usage_error', () => {
expect(parseSectionFlag(['--section', 'bogus'])).toBe('usage_error');
expect(parseSectionFlag(['--section=nonsense'])).toBe('usage_error');
});
test('every valid section is accepted', () => {
for (const s of ['sync', 'cycle', 'locks', 'workers', 'queue', 'autopilot']) {
const r = parseSectionFlag(['--section', s]);
expect(r).toBeInstanceOf(Set);
expect((r as Set<string>).has(s)).toBe(true);
}
});
});
describe('runStatus exit codes', () => {
test('--section invalid → exit 2 (usage error)', async () => {
let captured = '';
const r = await runStatus(null, ['--section', 'bogus'], {
stdout: () => {},
stderr: (s: string) => {
captured += s;
},
});
expect(r.exitCode).toBe(2);
expect(captured).toContain('invalid --section');
});
test('local mode with engine=null → exit 1 (snapshot failure)', async () => {
let captured = '';
const r = await runStatus(null, [], {
stdout: () => {},
stderr: (s: string) => {
captured += s;
},
});
// Without a config + engine, status can't build the local snapshot.
expect(r.exitCode).toBe(1);
expect(captured).toMatch(/snapshot failed|no engine connected/);
});
test('#1984: invalid --deadline-ms → exit 2 (usage error)', async () => {
let captured = '';
const r = await runStatus(null, ['--deadline-ms', '0'], {
stdout: () => {},
stderr: (s: string) => { captured += s; },
});
expect(r.exitCode).toBe(2);
expect(captured).toContain('--deadline-ms');
});
});