Garry's Opinionated OpenClaw/Hermes Agent Brain
TypeScript
/**
* E2E test pinning the PostgresEngine.disconnect() idempotency invariant.
*
* Background: when commit 671ef099 added engine.disconnect() to
* MinionWorker.start()'s finally block, every test that calls worker.start()
* AND then engine.disconnect() in its own finally was double-disconnecting
* the same engine instance. Pre-fix, the second disconnect found _sql=null
* and fell through to the `else` branch which calls db.disconnect() — but
* db.disconnect() clears the GLOBAL module-level connection, breaking
* unrelated downstream tests (their getConn() throws "no database
* connection" on the next beforeEach).
*
* The fix: PostgresEngine tracks `_connectionStyle` ('instance' | 'module')
* and only calls db.disconnect() when it actually owns the module-level
* connection. Second disconnect on an instance-pool engine is a no-op.
*
* This test pins the contract so future refactors of disconnect() can't
* silently regress (it's exactly the bug class that took an hour of E2E
* debugging to find). Two cases:
* 1. instance-pool engine: connect → disconnect → disconnect must NOT
* affect the module-level connection.
* 2. module-singleton engine: connect → disconnect → disconnect is safe
* (second call no-ops).
*/
import { describe, test, expect, beforeEach, afterAll } from 'bun:test';
import { PostgresEngine } from '../../src/core/postgres-engine.ts';
import * as db from '../../src/core/db.ts';
const DATABASE_URL = process.env.DATABASE_URL;
const skip = !DATABASE_URL;
if (skip) {
// eslint-disable-next-line no-console
console.log('Skipping postgres-engine-disconnect-idempotency E2E (DATABASE_URL not set)');
}
const ok1 = (rows: unknown[]) => (rows[0] as { ok: number }).ok;
describe.skipIf(skip)('PostgresEngine.disconnect idempotency + module-singleton ownership (#1471)', () => {
// Every test builds its own module-singleton scenario from a clean slate, so
// order is irrelevant and the ownership cases don't leak state into each other.
beforeEach(async () => {
await db.disconnect();
}, 30_000);
afterAll(async () => {
await db.disconnect();
});
test('instance-pool engine: second disconnect() does NOT clobber module singleton', async () => {
// Establish a module-level baseline (the cycle's singleton).
await db.connect({ database_url: DATABASE_URL! });
const engine = new PostgresEngine();
await engine.connect({ database_url: DATABASE_URL!, poolSize: 2 });
await engine.disconnect();
expect(ok1(await db.getConnection().unsafe('SELECT 1 as ok'))).toBe(1);
// Second disconnect — pre-fix this fell through to db.disconnect() and
// cleared the module-level singleton. Post-fix it's a no-op (instance style).
await engine.disconnect();
expect(ok1(await db.getConnection().unsafe('SELECT 1 as ok'))).toBe(1);
});
test('owner-first / borrower-second: a borrower disconnect must NOT null the owner singleton', async () => {
// The exact dream-cycle bug: the owner (cycle engine) creates the singleton,
// a probe (lint/doctor config-lift) borrows it, the probe disconnects, and
// pre-fix that nulled the singleton the owner was still using.
const owner = new PostgresEngine();
await owner.connect({ database_url: DATABASE_URL! }); // module branch → creates → owns
const borrower = new PostgresEngine();
await borrower.connect({ database_url: DATABASE_URL! }); // singleton exists → borrows
await borrower.disconnect(); // pre-fix: db.disconnect() → singleton null
// The owner must still be able to run DB work (this is sync/synthesize).
expect(ok1(await owner.executeRaw('SELECT 1 as ok'))).toBe(1);
expect(() => db.getConnection()).not.toThrow();
// And the owner — the true creator — DOES tear it down.
await owner.disconnect();
expect(() => db.getConnection()).toThrow(/No database connection/);
});
test('ownership tracks CREATION, not role: a probe that creates the singleton owns it', async () => {
// codex #2: ownership is not "the cycle engine" by name — it is whoever
// atomically created the pool. If a probe creates first, it owns; a later
// joiner is the borrower. (Safe in gbrain because the CLI engine is always
// the first creator and last to disconnect — the dominance invariant.)
const firstCreator = new PostgresEngine();
await firstCreator.connect({ database_url: DATABASE_URL! }); // creates → owns
const joiner = new PostgresEngine();
await joiner.connect({ database_url: DATABASE_URL! }); // joins → borrows
await joiner.disconnect(); // no-op on the singleton
expect(() => db.getConnection()).not.toThrow();
await firstCreator.disconnect(); // creator tears down
expect(() => db.getConnection()).toThrow(/No database connection/);
});
test('symmetric CLI-exit: a sole owner connect+disconnect tears the singleton down (no hang regression)', async () => {
const engine = new PostgresEngine();
await engine.connect({ database_url: DATABASE_URL! });
await engine.disconnect();
// Pool must be CLOSED so the CLI event loop drains and `gbrain init` /
// op-dispatch exit cleanly (the failure mode refcount would risk).
expect(() => db.getConnection()).toThrow(/No database connection/);
// Idempotent second disconnect.
await expect(engine.disconnect()).resolves.toBeUndefined();
});
test('a second disconnect() does not run the before-disconnect hooks again, as on PGLite', async () => {
for (const connect of [
(e: PostgresEngine) => e.connect({ database_url: DATABASE_URL!, poolSize: 2 }), // instance pool
(e: PostgresEngine) => e.connect({ database_url: DATABASE_URL! }), // module singleton
]) {
const engine = new PostgresEngine();
await connect(engine);
let runs = 0;
engine.registerBeforeDisconnect(async () => { runs++; });
await engine.disconnect();
expect(runs).toBe(1);
await engine.disconnect();
expect(runs).toBe(1);
}
});
test('owner reconnect with a live borrower: borrower resolves the rebuilt singleton', async () => {
const owner = new PostgresEngine();
await owner.connect({ database_url: DATABASE_URL! }); // owns
const borrower = new PostgresEngine();
await borrower.connect({ database_url: DATABASE_URL! }); // borrows
// Owner reconnect (the batchRetry path): tears down the old singleton and
// builds a fresh one, re-acquiring ownership via the atomic db.connect() token.
await owner.reconnect();
// The borrower's normal query path (this.sql → db.getConnection()) resolves
// the NEW singleton. (codex #4: the borrower's cached connectionManager pool
// is stale — that ddl()-only edge is a filed TODO, not this normal path.)
expect(ok1(await borrower.sql.unsafe('SELECT 1 as ok'))).toBe(1);
expect(ok1(await owner.executeRaw('SELECT 1 as ok'))).toBe(1);
await owner.disconnect();
expect(() => db.getConnection()).toThrow(/No database connection/);
});
});