GitNexus/gitnexus/test/integration/lbug-pool-stability.test.ts

/**
 * Integration Tests: LadybugDB Connection Pool — Parallel Stability
 *
 * Tests concurrency fixes from PR #349:
 *   - Pre-warmed pool handles max parallel queries
 *   - Waiter queue drains under overload
 *   - Concurrent initLbug deduplication
 *   - stdout.write restoration after parallel operations
 *   - No connection leaks over sequential workloads
 *   - Atomic pool entry visibility (pool.set last)
 *   - Mixed query types at full concurrency
 *
 * Connection budget: LadybugDB's native mmap budget caps at ~56
 * simultaneous Connection objects per process.  Tests that only need
 * a ready pool share a single 'shared-repo' init (8 connections) to
 * stay well under the limit.
 */
import { it, expect, afterAll } from 'vitest';
import {
  initLbug,
  executeQuery,
  executeParameterized,
  closeLbug,
  isLbugReady,
} from '../../src/mcp/core/lbug-adapter.js';
import { withTestLbugDB } from '../helpers/test-indexed-db.js';

const SEED_DATA = [
  `CREATE (f:File {id: 'file:index.ts', name: 'index.ts', filePath: 'src/index.ts', content: ''})`,
  `CREATE (fn:Function {id: 'func:main', name: 'main', filePath: 'src/index.ts', startLine: 1, endLine: 10, isExported: true, content: '', description: ''})`,
  `CREATE (fn2:Function {id: 'func:helper', name: 'helper', filePath: 'src/utils.ts', startLine: 1, endLine: 5, isExported: true, content: '', description: ''})`,
  `MATCH (a:Function), (b:Function)
    WHERE a.id = 'func:main' AND b.id = 'func:helper'
    CREATE (a)-[:CodeRelation {type: 'CALLS', confidence: 1.0, reason: 'direct', step: 0}]->(b)`,
];

// ─── Shared-pool tests: reuse one init across 5 tests (8 connections total) ──

withTestLbugDB('pool-stability', (handle) => {
  const REPO = 'shared-par';
  let inited = false;

  const ensurePool = async () => {
    if (!inited) {
      await initLbug(REPO, handle.dbPath);
      inited = true;
    }
  };

  afterAll(async () => {
    try { await closeLbug(REPO); } catch { /* best-effort */ }
  });

  it('8 simultaneous queries complete without crashes', async () => {
    await ensurePool();
    const queries = Array.from({ length: 8 }, () =>
      executeQuery(REPO, 'MATCH (n:Function) RETURN n.name AS name')
    );
    const results = await Promise.all(queries);
    expect(results).toHaveLength(8);
    for (const rows of results) {
      expect(rows.length).toBeGreaterThanOrEqual(2);
    }
  });

  it('12 parallel queries overflow into waiter queue and all complete', async () => {
    await ensurePool();
    const queries = Array.from({ length: 12 }, () =>
      executeQuery(REPO, 'MATCH (n:Function) RETURN n.name AS name')
    );
    const results = await Promise.all(queries);
    expect(results).toHaveLength(12);
    for (const rows of results) {
      expect(rows.length).toBeGreaterThanOrEqual(2);
    }
  });

  it('process.stdout.write is functional after init and parallel queries', async () => {
    await ensurePool();
    const queries = Array.from({ length: 8 }, () =>
      executeQuery(REPO, 'MATCH (n:Function) RETURN n.name AS name')
    );
    await Promise.all(queries);
    // stdout.write should be the real function, not the silenced no-op
    expect(typeof process.stdout.write).toBe('function');
  });

  it('50 sequential queries do not leak connections', async () => {
    await ensurePool();
    for (let i = 0; i < 50; i++) {
      await executeQuery(REPO, 'MATCH (n:Function) RETURN n.name AS name');
    }
    // If connections leaked, these 8 parallel queries would exhaust the pool
    const queries = Array.from({ length: 8 }, () =>
      executeQuery(REPO, 'MATCH (n:Function) RETURN n.name AS name')
    );
    const results = await Promise.all(queries);
    expect(results).toHaveLength(8);
  });

  it('mixed executeQuery + executeParameterized at full concurrency', async () => {
    await ensurePool();
    const queries = [
      executeQuery(REPO, 'MATCH (n:Function) RETURN n.name AS name'),
      executeParameterized(REPO, 'MATCH (n:Function) WHERE n.name = $name RETURN n.name AS name', { name: 'main' }),
      executeQuery(REPO, 'MATCH (n:Function) RETURN n.name AS name'),
      executeParameterized(REPO, 'MATCH (n:Function) WHERE n.name = $name RETURN n.name AS name', { name: 'helper' }),
      executeQuery(REPO, 'MATCH (n:Function) RETURN n.name AS name'),
      executeParameterized(REPO, 'MATCH (n:Function) WHERE n.name = $name RETURN n.name AS name', { name: 'main' }),
      executeQuery(REPO, 'MATCH (n:Function) RETURN n.name AS name'),
      executeQuery(REPO, 'MATCH (n:Function) RETURN n.name AS name'),
    ];
    const results = await Promise.all(queries);
    expect(results).toHaveLength(8);
  });

  // ─── Regression tests for #308 / #314 / #347 ──────────────────────────
  // The impact command's enrichment phase runs 3 concurrent queries via
  // Promise.all (local-backend.ts:1415). Before PR #349's pool pre-warming,
  // this triggered lazy createConnection → silenceStdout → SIGSEGV.

  it('3 concurrent queries via Promise.all (impact enrichment pattern, #308/#314/#347)', async () => {
    await ensurePool();
    // Mirrors the exact Promise.all pattern from local-backend.ts:1415
    // that caused SIGSEGV in issues #308, #314, #347 before pool pre-warming.
    const [r1, r2, r3] = await Promise.all([
      executeQuery(REPO, 'MATCH (n:Function) RETURN n.name AS name LIMIT 5').catch(() => []),
      executeQuery(REPO, 'MATCH (n:Function) RETURN n.id AS id LIMIT 5').catch(() => []),
      executeQuery(REPO, 'MATCH ()-[r:CodeRelation]->() RETURN r.type AS type LIMIT 5').catch(() => []),
    ]);
    expect(r1.length).toBeGreaterThanOrEqual(1);
    expect(r2.length).toBeGreaterThanOrEqual(1);
    expect(r3.length).toBeGreaterThanOrEqual(1);
  });

  // ─── Fresh-state tests: need their own init ──────────────────────────

  it('concurrent initLbug calls for the same repoId deduplicate', async () => {
    const promises = Array.from({ length: 6 }, () =>
      initLbug('dedup-repo', handle.dbPath)
    );
    await Promise.all(promises);
    expect(isLbugReady('dedup-repo')).toBe(true);
    const rows = await executeQuery('dedup-repo', 'MATCH (n:Function) RETURN n.name AS name');
    expect(rows.length).toBeGreaterThanOrEqual(2);
    await closeLbug('dedup-repo');
  });

  it('pool entry is not visible until initLbug fully resolves', async () => {
    const initPromise = initLbug('atomic-repo', handle.dbPath);
    // Synchronously, pool should NOT be ready (pool.set is the last operation)
    expect(isLbugReady('atomic-repo')).toBe(false);
    await initPromise;
    expect(isLbugReady('atomic-repo')).toBe(true);
    await closeLbug('atomic-repo');
  });
}, {
  seed: SEED_DATA,
  poolAdapter: true,
});