Skip to content

Garry's Opinionated OpenClaw/Hermes Agent Brain

TypeScript

Test that an upgraded brain pins the same search_path on every function as a fresh one

garrytan933b95e2b2d0
diff --git a/scripts/postgres-arm-weights.json b/scripts/postgres-arm-weights.json
index e0f15eec32..9c81938712 100644
--- a/scripts/postgres-arm-weights.json
+++ b/scripts/postgres-arm-weights.json
@@ -114,6 +114,7 @@
"test/file-drift-soft-delete-hold-release-gbra133.test.ts": 20851,
"test/forecast-journal.test.ts": 33091,
"test/frontmatter-reserved-keys-6454.test.ts": 9014,
+ "test/function-search-path-upgrade-parity.test.ts": 9500,
"test/g4-forget-fence-edit.test.ts": 100033,
"test/gated-hold-strict-page-gst2535.test.ts": 58877,
"test/get-chunks-paging.test.ts": 7403,
diff --git a/scripts/test-weights.json b/scripts/test-weights.json
index d79acb4f0f..98f912c549 100644
--- a/scripts/test-weights.json
+++ b/scripts/test-weights.json
@@ -1659,6 +1659,7 @@
"test/fts-cjk-boundary-search.test.ts": 1036,
"test/fts-cjk-boundary.test.ts": 1456,
"test/function-search-path-pglite.test.ts": 440,
+ "test/function-search-path-upgrade-parity.test.ts": 4700,
"test/funnel-cli.test.ts": 8386,
"test/funnel-ops.test.ts": 2526,
"test/funnel.test.ts": 4,
diff --git a/test/function-search-path-upgrade-parity.test.ts b/test/function-search-path-upgrade-parity.test.ts
new file mode 100644
index 0000000000..4de3375d42
--- /dev/null
+++ b/test/function-search-path-upgrade-parity.test.ts
@@ -0,0 +1,127 @@
+/**
+ * A brain whose gbrain functions still pin the search_path they pinned before pg_temp (every brain migrated before
+ * v277, #7632), upgraded on this code, ends with the same search_path on every function as a brain created fresh here.
+ *
+ * 1. Protects: every definition now pins pg_temp itself (#7785), while an existing brain gets it only from the
+ * hardening (migration v277 and the end of every migration run, src/core/migrate.ts). Both routes must land on the
+ * same pg_proc.proconfig for every function: the same functions, identity arguments and settings, pg_temp last.
+ * 2. Fails when: the hardening is skipped or appends anything but pg_temp, a definition pins a path the hardening would
+ * not produce from the legacy one (pg_temp elsewhere, a schema added or dropped), or an upgrade leaves a function
+ * behind.
+ * 3. Existing coverage: test/e2e/function-search-path-postgres.test.ts case 4 compares the count of pinned functions
+ * and the list without pg_temp, on Postgres and through runMigrations only. This file compares every function's
+ * full proconfig, on PGLite and Postgres, through initSchema and runMigrations.
+ * 4. Real seams: PGLite cold in-memory brains (no schema snapshot) and, with DATABASE_URL, fresh Postgres databases;
+ * initSchema (the gbrain upgrade and apply-migrations entry) and runMigrations.
+ */
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
+import type { BrainEngine } from '../src/core/engine.ts';
+import { PGLiteEngine } from '../src/core/pglite-engine.ts';
+import { LATEST_VERSION, runMigrations } from '../src/core/migrate.ts';
+import { LEGACY_SEARCH_PATH_SETTINGS, PINNED_FUNCTION_NAMES, legacySearchPathFunctions } from '../src/core/function-search-path.ts';
+import { v277 } from '../src/core/schema-migrations/v277-function-search-path-pg-temp.ts';
+import { isolatedPersistencePostgres } from './helpers/persistence-postgres.ts';
+import { testBackends } from './helpers/test-backends.ts';
+import { withColdPglite } from './helpers/with-snapshot.ts';
+
+/** Every function outside the system schemas that no extension owns, with its full proconfig. */
+const FUNCTIONS_SQL = `SELECT n.nspname || '.' || p.proname || '(' || pg_get_function_identity_arguments(p.oid) || ')' AS fn,
+ p.oid::regprocedure::text AS sig, p.proname AS name, COALESCE(p.proconfig, '{}'::text[]) AS config
+ FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace
+ WHERE n.nspname NOT IN ('pg_catalog', 'information_schema') AND n.nspname NOT LIKE 'pg\\_%'
+ AND NOT EXISTS (SELECT 1 FROM pg_depend d WHERE d.classid = 'pg_proc'::regclass AND d.objid = p.oid AND d.deptype = 'e')`;
+const PREFIX = 'search_path=';
+const PG_TEMP = ', pg_temp';
+
+type Fn = { fn: string; sig: string; name: string; config: string[] };
+type Brain = { engine: BrainEngine; close: () => Promise<void> };
+
+async function functions(engine: BrainEngine): Promise<Fn[]> {
+ const rows = await engine.executeRaw<Fn>(FUNCTIONS_SQL);
+ return rows.map(r => ({ fn: r.fn, sig: r.sig, name: r.name, config: [...r.config] })).sort((a, b) => (a.fn < b.fn ? -1 : a.fn > b.fn ? 1 : 0));
+}
+const searchPath = (f: Fn) => f.config.find(c => c.startsWith(PREFIX));
+const pinned = (fns: Fn[]) => fns.filter(f => searchPath(f) !== undefined);
+const shape = (fns: Fn[]) => fns.map(f => ({ fn: f.fn, config: f.config }));
+function pgTempLast(setting: string): boolean {
+ const schemas = setting.slice(PREFIX.length).split(',').map(s => s.trim());
+ return schemas.indexOf('pg_temp') === schemas.length - 1;
+}
+
+/** Puts every pinned function back on the setting it had before pg_temp (ALTER only, as the hardening undoes) at 'version'. */
+async function rewindToLegacy(engine: BrainEngine, version: number): Promise<void> {
+ for (const f of await functions(engine)) {
+ const setting = searchPath(f);
+ if (!setting?.endsWith(PG_TEMP)) continue;
+ await engine.executeRaw(`ALTER FUNCTION ${f.sig} SET search_path = ${setting.slice(PREFIX.length, -PG_TEMP.length)}`);
+ }
+ await engine.setConfig('version', String(version));
+}
+
+async function capturingStderr(fn: () => Promise<unknown>): Promise<string> {
+ const write = process.stderr.write.bind(process.stderr);
+ let stderr = '';
+ process.stderr.write = ((chunk: string | Uint8Array) => { stderr += String(chunk); return true; }) as typeof process.stderr.write;
+ try { await fn(); } finally { process.stderr.write = write; }
+ return stderr;
+}
+
+const ENTRIES: Array<[string, (engine: BrainEngine) => Promise<unknown>]> = [
+ ['initSchema (gbrain upgrade, apply-migrations)', engine => engine.initSchema()],
+ ['runMigrations', engine => runMigrations(engine)],
+];
+const STATES: Array<[string, number]> = [
+ ['migrated before v277', v277.version - 1],
+ ['at the latest version with every legacy path (nothing pending)', LATEST_VERSION],
+];
+
+for (const kind of testBackends()) {
+ describe(`an upgraded brain pins the same search_path on every function as a fresh one (${kind})`, () => {
+ let fresh: Brain | undefined;
+ let upgraded: Brain | undefined;
+ let freshFns: Fn[] = [];
+ beforeAll(async () => {
+ const freshBrain = async (): Promise<Brain> => {
+ if (kind === 'postgres') return isolatedPersistencePostgres(process.env.DATABASE_URL!);
+ const engine = new PGLiteEngine();
+ await withColdPglite(() => engine.connect({}));
+ await engine.initSchema();
+ return { engine, close: () => engine.disconnect() };
+ };
+ fresh = await freshBrain();
+ upgraded = await freshBrain();
+ freshFns = await functions(fresh.engine);
+ }, 300_000);
+ afterAll(async () => {
+ await fresh?.close();
+ await upgraded?.close();
+ });
+
+ test('a fresh brain pins pg_temp last on every pinned function, and pins only the functions the hardening knows', () => {
+ const pins = pinned(freshFns);
+ expect(pins.length).toBeGreaterThanOrEqual(35);
+ expect(pins.filter(f => !pgTempLast(searchPath(f)!)).map(f => f.fn)).toEqual([]);
+ expect(pins.map(f => f.name).filter(name => !(PINNED_FUNCTION_NAMES as readonly string[]).includes(name))).toEqual([]);
+ });
+
+ for (const [entry, migrate] of ENTRIES) {
+ for (const [state, version] of STATES) {
+ test(`a brain ${state}, upgraded through ${entry}, ends with every function's proconfig as on a fresh brain`, async () => {
+ const engine = upgraded!.engine;
+ await rewindToLegacy(engine, version);
+ const legacy = pinned(await functions(engine));
+ expect(legacy.length).toBe(pinned(freshFns).length);
+ expect(legacy.filter(f => !(LEGACY_SEARCH_PATH_SETTINGS as readonly string[]).includes(searchPath(f)!)).map(f => f.fn)).toEqual([]);
+ expect((await legacySearchPathFunctions(engine)).length).toBe(legacy.length);
+
+ const stderr = await capturingStderr(() => migrate(engine));
+ expect(await engine.getConfig('version')).toBe(String(LATEST_VERSION));
+ expect(stderr).not.toMatch(/left without pg_temp|pg_temp not restored|not put back/);
+ const after = await functions(engine);
+ expect(shape(after)).toEqual(shape(freshFns));
+ expect(pinned(after).filter(f => !pgTempLast(searchPath(f)!)).map(f => f.fn)).toEqual([]);
+ }, 300_000);
+ }
+ }
+ });
+}
diff --git a/test/postgres-unit-arms.txt b/test/postgres-unit-arms.txt
index 4b86f8c66f..cf2129d625 100644
--- a/test/postgres-unit-arms.txt
+++ b/test/postgres-unit-arms.txt
@@ -126,6 +126,7 @@ test/fenced-embed-reuse-6961.test.ts
test/file-drift-soft-delete-hold-release-gbra133.test.ts
test/forecast-journal.test.ts
test/frontmatter-reserved-keys-6454.test.ts
+test/function-search-path-upgrade-parity.test.ts
test/g4-forget-fence-edit.test.ts
test/gated-hold-strict-page-gst2535.test.ts
test/get-chunks-paging.test.ts