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 fs from 'node:fs/promises';
import os from 'node:os';
import path from 'node:path';
import lbug from '@ladybugdb/core';
import {
  initLbug,
  executeQuery,
  executeParameterized,
  closeLbug,
  isLbugReady,
} from '../../src/mcp/core/lbug-adapter.js';
import { withTestLbugDB } from '../helpers/test-indexed-db.js';
import { createLbugDatabase } from '../../src/core/lbug/lbug-config.js';
import { closeQueryResults } from '../../src/core/lbug/query-result-utils.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,
  },
);

// Windows cannot atomically replace a file held by a native reader. The same
// shared-consumer refresh logic has portable coverage in lbug-pool-pinning.
it.skipIf(process.platform === 'win32')(
  'keeps shared readers on one native generation until the other consumer releases it',
  async () => {
    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'gn-shared-refresh-'));
    const dbPath = path.join(root, 'lbug');
    const nextPath = path.join(root, 'next-lbug');
    const reader = 'generation-reader';
    const holder = 'generation-holder';

    async function seed(dbFile: string, name: string): Promise<void> {
      const db = createLbugDatabase(lbug, dbFile);
      let conn: lbug.Connection | undefined;
      try {
        await db.init();
        conn = new lbug.Connection(db);
        for (const query of [
          'CREATE NODE TABLE Entry(name STRING, PRIMARY KEY(name))',
          `CREATE (:Entry {name: '${name}'})`,
          'CHECKPOINT',
        ]) {
          const result = await conn.query(query);
          try {
            for (const item of Array.isArray(result) ? result : [result]) {
              await item.getAll();
            }
          } finally {
            await closeQueryResults(result);
          }
        }
      } finally {
        await conn?.close();
        await db.close();
      }
    }

    const read = (repoId: string) => executeQuery(repoId, 'MATCH (n:Entry) RETURN n.name AS name');
    try {
      await seed(dbPath, 'before');
      await seed(nextPath, 'after');
      await initLbug(reader, dbPath);
      await initLbug(holder, dbPath);
      expect(await read(reader)).toEqual([{ name: 'before' }]);
      await fs.rename(nextPath, dbPath);

      for (let i = 0; i < 3; i++) {
        expect(await initLbug(reader, dbPath)).toBe(false);
        expect(await read(reader)).toEqual([{ name: 'before' }]);
        expect(await read(holder)).toEqual([{ name: 'before' }]);
      }
      await closeLbug(holder);
      expect(await initLbug(reader, dbPath)).toBe(true);
      expect(await read(reader)).toEqual([{ name: 'after' }]);
      expect(await initLbug(reader, dbPath)).toBe(false);
    } finally {
      await closeLbug(holder);
      await closeLbug(reader);
      await fs.rm(root, { recursive: true, force: true });
    }
  },
  120_000,
);