pgserve 2.1.2 → 2.2.0

package/tests/router-handshake-retry.test.js

@@ -1,119 +0,0 @@
-/**
- * Backend connect retry with 57P03 fallback
- *
- * Verifies the handshake-time backend-connect path:
- *  1. First connect succeeds → returns the socket (no retry).
- *  2. First connect fails, retry succeeds → returns the retry socket
- *     (after the documented 200ms backoff).
- *  3. Both attempts fail → throws the second error.
- *  4. The 57P03 ErrorResponse frame is well-formed Postgres wire bytes
- *     (libpq parses it cleanly).
- *
- * The retry helper is unexported (module-private) — we re-implement
- * the assertion against the same `Bun.connect` injection seam by
- * stubbing `Bun.connect` for the duration of each test.
- */
-
-import { test, expect, mock } from 'bun:test';
-import { buildErrorResponse } from '../src/protocol.js';
-
-test('57P03 ErrorResponse frame is well-formed', () => {
-  const frame = buildErrorResponse({
-    severity: 'FATAL',
-    sqlstate: '57P03',
-    message: 'backend unavailable, retry shortly',
-  });
-
-  // Postgres wire: type byte 'E' (0x45), then 4-byte length (network order),
-  // then null-terminated field strings, then a trailing null byte.
-  expect(frame[0]).toBe(0x45);
-
-  const length = frame.readUInt32BE(1);
-  // Length includes itself (4 bytes) + the body. Frame total = 1 (type) + length.
-  expect(frame.length).toBe(1 + length);
-
-  // Find the SQLSTATE field marker (`C` = 0x43).
-  const body = frame.subarray(5).toString('latin1');
-  expect(body).toContain('C57P03'); // C + sqlstate value
-  expect(body).toContain('SFATAL');   // S + severity
-  expect(body).toContain('Mbackend unavailable, retry shortly');
-});
-
-test('Bun.connect retry: first attempt succeeds → no retry', async () => {
-  const realConnect = Bun.connect;
-  let attempts = 0;
-  const fakeSocket = { ok: true };
-  Bun.connect = mock(async () => {
-    attempts++;
-    return fakeSocket;
-  });
-  try {
-    // Inline the same shape as connectBackendWithRetry for an integration-style
-    // assertion that doesn't require exporting a private helper.
-    const tryOnce = () => Bun.connect({ hostname: '127.0.0.1', port: 0, socket: {} });
-    let result;
-    try {
-      result = await tryOnce();
-    } catch {
-      await new Promise((r) => setTimeout(r, 50));
-      result = await tryOnce();
-    }
-    expect(result).toBe(fakeSocket);
-    expect(attempts).toBe(1);
-  } finally {
-    Bun.connect = realConnect;
-  }
-});
-
-test('Bun.connect retry: first fails, second succeeds → exactly 2 attempts', async () => {
-  const realConnect = Bun.connect;
-  let attempts = 0;
-  const fakeSocket = { ok: true };
-  Bun.connect = mock(async () => {
-    attempts++;
-    if (attempts === 1) throw new Error('ECONNREFUSED');
-    return fakeSocket;
-  });
-  try {
-    const tryOnce = () => Bun.connect({ hostname: '127.0.0.1', port: 0, socket: {} });
-    let result;
-    try {
-      result = await tryOnce();
-    } catch {
-      await new Promise((r) => setTimeout(r, 50));
-      result = await tryOnce();
-    }
-    expect(result).toBe(fakeSocket);
-    expect(attempts).toBe(2);
-  } finally {
-    Bun.connect = realConnect;
-  }
-});
-
-test('Bun.connect retry: both attempts fail → final error propagates', async () => {
-  const realConnect = Bun.connect;
-  let attempts = 0;
-  Bun.connect = mock(async () => {
-    attempts++;
-    throw new Error(`ECONNREFUSED-${attempts}`);
-  });
-  try {
-    const tryOnce = () => Bun.connect({ hostname: '127.0.0.1', port: 0, socket: {} });
-    let final;
-    try {
-      try {
-        await tryOnce();
-      } catch {
-        await new Promise((r) => setTimeout(r, 50));
-        await tryOnce();
-      }
-    } catch (err) {
-      final = err;
-    }
-    expect(final).toBeDefined();
-    expect(final.message).toBe('ECONNREFUSED-2'); // Second-attempt message wins
-    expect(attempts).toBe(2);
-  } finally {
-    Bun.connect = realConnect;
-  }
-});

package/tests/router-handshake-watchdog.test.js

@@ -1,110 +0,0 @@
-/**
- * Handshake watchdog: peers that connect and never complete the postgres
- * StartupMessage are forcibly closed past `PGSERVE_HANDSHAKE_DEADLINE_MS`.
- *
- * Regression coverage: pgserve#45 documented file-descriptor leak where
- * peers piled up indefinitely in `state.handshakeComplete=false`.
- *
- * The tests drive `_sweepStuckHandshakes()` directly via a synthetic
- * connection record. This avoids spawning a real postgres backend, which
- * is unnecessary when we only want to assert the sweep policy and timer
- * lifecycle.
- */
-
-import { PgserveDaemon } from '../src/daemon.js';
-import { test, expect } from 'bun:test';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-
-function quietLogger() {
-  return {
-    info: () => {}, warn: () => {}, error: () => {}, debug: () => {},
-    child: () => quietLogger(),
-  };
-}
-
-function makeDaemon(opts = {}) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pgserve-watchdog-'));
-  const daemon = new PgserveDaemon({
-    baseDir: dir,
-    logger: quietLogger(),
-    enforcementDisabled: true,
-    ...opts,
-  });
-  return { daemon, dir };
-}
-
-function fakeSocket() {
-  const calls = [];
-  return {
-    end: () => { calls.push('end'); },
-    pause: () => {}, resume: () => {}, write: () => 0,
-    _calls: calls,
-  };
-}
-
-test('handshakeDeadlineMs falls back to 30000 when env unset', () => {
-  delete process.env.PGSERVE_HANDSHAKE_DEADLINE_MS;
-  const { daemon, dir } = makeDaemon();
-  expect(daemon.handshakeDeadlineMs).toBe(30000);
-  fs.rmSync(dir, { recursive: true, force: true });
-});
-
-test('handshakeDeadlineMs honours PGSERVE_HANDSHAKE_DEADLINE_MS env', () => {
-  process.env.PGSERVE_HANDSHAKE_DEADLINE_MS = '2000';
-  try {
-    const { daemon, dir } = makeDaemon();
-    expect(daemon.handshakeDeadlineMs).toBe(2000);
-    fs.rmSync(dir, { recursive: true, force: true });
-  } finally {
-    delete process.env.PGSERVE_HANDSHAKE_DEADLINE_MS;
-  }
-});
-
-test('_sweepStuckHandshakes closes pre-handshake sockets past deadline', () => {
-  const { daemon, dir } = makeDaemon({ handshakeDeadlineMs: 100 });
-  const sock = fakeSocket();
-  const stuckAt = Date.now() - 500; // older than 100ms deadline
-  daemon.connections.add(sock);
-  daemon.socketState.set(sock, { handshakeComplete: false, acceptedAt: stuckAt });
-  const closed = daemon._sweepStuckHandshakes();
-  expect(closed).toBe(1);
-  expect(sock._calls).toContain('end');
-  expect(daemon.connections.has(sock)).toBe(false);
-  expect(daemon.socketState.has(sock)).toBe(false);
-  fs.rmSync(dir, { recursive: true, force: true });
-});
-
-test('_sweepStuckHandshakes leaves fresh pre-handshake sockets alone', () => {
-  const { daemon, dir } = makeDaemon({ handshakeDeadlineMs: 30000 });
-  const sock = fakeSocket();
-  daemon.connections.add(sock);
-  daemon.socketState.set(sock, { handshakeComplete: false, acceptedAt: Date.now() });
-  const closed = daemon._sweepStuckHandshakes();
-  expect(closed).toBe(0);
-  expect(sock._calls).not.toContain('end');
-  expect(daemon.connections.has(sock)).toBe(true);
-  fs.rmSync(dir, { recursive: true, force: true });
-});
-
-test('_sweepStuckHandshakes leaves completed-handshake sockets alone even past deadline', () => {
-  const { daemon, dir } = makeDaemon({ handshakeDeadlineMs: 100 });
-  const sock = fakeSocket();
-  daemon.connections.add(sock);
-  daemon.socketState.set(sock, { handshakeComplete: true, acceptedAt: Date.now() - 5000 });
-  const closed = daemon._sweepStuckHandshakes();
-  expect(closed).toBe(0);
-  expect(sock._calls).not.toContain('end');
-  fs.rmSync(dir, { recursive: true, force: true });
-});
-
-test('handshakeSweepIntervalMs is bounded sensibly relative to deadline', () => {
-  const { daemon, dir } = makeDaemon({
-    handshakeDeadlineMs: 200,
-    handshakeSweepIntervalMs: 50,
-  });
-  // Sweep interval cannot drop below 1s safety floor.
-  expect(daemon.handshakeSweepIntervalMs).toBe(1000);
-  fs.rmSync(dir, { recursive: true, force: true });
-});

package/tests/sdk.test.js

@@ -1,71 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-
-import {
-  buildDaemonArgs,
-  daemonClientOptions,
-  probeDaemon,
-  resolveLibpqCompatPath,
-  resolvePidLockPath,
-} from '../src/index.js';
-
-function makeDir(tag) {
-  const dir = path.join(os.tmpdir(), `pgserve-sdk-${tag}-${process.pid}-${Date.now()}`);
-  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-  return dir;
-}
-
-describe('SDK daemon helpers', () => {
-  test('daemonClientOptions returns libpq socket connection settings', () => {
-    expect(daemonClientOptions({ controlSocketDir: '/tmp/pgserve' })).toEqual({
-      host: '/tmp/pgserve',
-      port: 5432,
-      database: 'postgres',
-      username: 'postgres',
-      password: '',
-    });
-  });
-
-  test('buildDaemonArgs exposes persistent, pgvector, and listen options', () => {
-    expect(buildDaemonArgs({
-      dataDir: '/var/lib/pgserve',
-      logLevel: 'warn',
-      pgvector: true,
-      listens: ['127.0.0.1:15432'],
-    })).toEqual([
-      'daemon',
-      '--data',
-      '/var/lib/pgserve',
-      '--log',
-      'warn',
-      '--pgvector',
-      '--listen',
-      '127.0.0.1:15432',
-    ]);
-  });
-
-  test('probeDaemon reports missing and stale daemon state', () => {
-    const dir = makeDir('probe');
-    try {
-      expect(probeDaemon({ controlSocketDir: dir })).toMatchObject({
-        running: false,
-        pid: null,
-        reason: 'no daemon',
-      });
-
-      fs.writeFileSync(resolvePidLockPath(dir), '999999', { mode: 0o600 });
-      fs.writeFileSync(path.join(dir, 'control.sock'), '');
-      fs.symlinkSync('control.sock', resolveLibpqCompatPath(dir));
-      expect(probeDaemon({ controlSocketDir: dir })).toMatchObject({
-        running: false,
-        pid: null,
-        libpqSocketPresent: true,
-        reason: 'stale pid',
-      });
-    } finally {
-      fs.rmSync(dir, { recursive: true, force: true });
-    }
-  });
-});

package/tests/stale-postmaster-pid.test.js

@@ -1,85 +0,0 @@
-/**
- * Stale postmaster.pid cleanup
- *
- * Verifies that PostgresManager._ensureNoStalePostmasterLock removes
- * a postmaster.pid file whose recorded PID is no longer alive, and
- * leaves alone a postmaster.pid whose recorded PID is alive.
- *
- * Regression coverage: postgres refuses to start when postmaster.pid
- * exists, even if the writer crashed. After unclean shutdowns this
- * required manual `rm` to recover.
- */
-
-import { PostgresManager } from '../src/postgres.js';
-import { test, expect } from 'bun:test';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-
-function makeMgr(dataDir) {
-  const mgr = new PostgresManager({ dataDir });
-  mgr.databaseDir = dataDir;
-  mgr.logger = {
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    debug: () => {},
-  };
-  return mgr;
-}
-
-function makePidFile(dir, contents) {
-  fs.mkdirSync(dir, { recursive: true });
-  const pidFile = path.join(dir, 'postmaster.pid');
-  fs.writeFileSync(pidFile, contents, 'utf-8');
-  return pidFile;
-}
-
-test('removes postmaster.pid when recorded PID is dead', async () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pgserve-stale-'));
-  try {
-    // PID 999999999 will not exist on any sane system
-    const pidFile = makePidFile(dir, '999999999\n/some/data\n123\n');
-    const mgr = makeMgr(dir);
-    await mgr._ensureNoStalePostmasterLock();
-    expect(fs.existsSync(pidFile)).toBe(false);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('keeps postmaster.pid when recorded PID is the current (alive) process', async () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pgserve-alive-'));
-  try {
-    const pidFile = makePidFile(dir, `${process.pid}\n/some/data\n123\n`);
-    const mgr = makeMgr(dir);
-    await mgr._ensureNoStalePostmasterLock();
-    expect(fs.existsSync(pidFile)).toBe(true);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('removes postmaster.pid when first line is unparseable', async () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pgserve-garbage-'));
-  try {
-    const pidFile = makePidFile(dir, 'garbage\nnot-a-pid\n');
-    const mgr = makeMgr(dir);
-    await mgr._ensureNoStalePostmasterLock();
-    expect(fs.existsSync(pidFile)).toBe(false);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('no-ops when postmaster.pid does not exist', async () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pgserve-missing-'));
-  try {
-    const mgr = makeMgr(dir);
-    // Should resolve without throwing
-    await mgr._ensureNoStalePostmasterLock();
-    expect(fs.existsSync(path.join(dir, 'postmaster.pid'))).toBe(false);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});