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.jsonindex 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.jsonindex 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.tsnew file mode 100644index 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.txtindex 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.tstest/file-drift-soft-delete-hold-release-gbra133.test.tstest/forecast-journal.test.tstest/frontmatter-reserved-keys-6454.test.ts+test/function-search-path-upgrade-parity.test.tstest/g4-forget-fence-edit.test.tstest/gated-hold-strict-page-gst2535.test.tstest/get-chunks-paging.test.ts