mirror of
https://github.com/abhigyanpatwari/GitNexus.git
synced 2026-10-11 03:38:07 +00:00
260 lines
9.7 KiB
TypeScript
260 lines
9.7 KiB
TypeScript
/**
|
|
* Integration test: loadGraphToLbug overlap ERROR paths (#2226 review F1/F2).
|
|
*
|
|
* The node-COPY ‖ relationship-emit overlap (#2203) added two error branches the
|
|
* happy-path tests don't exercise:
|
|
* - F1: relationship emit fails while node COPY is in flight — the emit error
|
|
* must surface from loadGraphToLbug AND the in-flight node-COPY promise must
|
|
* be settled, so nothing leaks as an unhandled rejection.
|
|
* - F2: node COPY itself fails — the captured error must be rethrown at the FK
|
|
* barrier rather than silently swallowed.
|
|
*
|
|
* Both are fault-injected by mocking `streamAllCSVsToDisk` so the test controls
|
|
* when `onNodePhaseComplete` fires (starting node COPY) and whether emit throws,
|
|
* while a REAL LadybugDB connection (`initLbug`) runs the node COPY. The mock
|
|
* pattern (vi.hoisted + vi.mock with importOriginal, preserving every other
|
|
* export) mirrors test/unit/api-graph-streaming.test.ts.
|
|
*/
|
|
import { describe, it, expect, beforeAll, afterAll, afterEach, vi } from 'vitest';
|
|
import fs from 'fs/promises';
|
|
import path from 'path';
|
|
import os from 'os';
|
|
import type { StreamedCSVResult } from '../../src/core/lbug/csv-generator.js';
|
|
import type { NodeTableName } from '../../src/core/lbug/schema.js';
|
|
import { buildTestGraph } from '../helpers/test-graph.js';
|
|
|
|
const { emitMock } = vi.hoisted(() => ({ emitMock: vi.fn() }));
|
|
|
|
// Replace ONLY streamAllCSVsToDisk; importOriginal preserves StreamedCSVResult
|
|
// and every other export lbug-adapter (and its transitive deps) rely on.
|
|
vi.mock('../../src/core/lbug/csv-generator.js', async (importOriginal) => {
|
|
const actual = await importOriginal<typeof import('../../src/core/lbug/csv-generator.js')>();
|
|
return { ...actual, streamAllCSVsToDisk: emitMock };
|
|
});
|
|
|
|
type NodeFiles = Map<NodeTableName, { csvPath: string; rows: number }>;
|
|
|
|
const REL_HEADER = 'from,to,type,confidence,reason,step';
|
|
const emptyResult = (): StreamedCSVResult => ({
|
|
nodeFiles: new Map(),
|
|
relsByPair: new Map(),
|
|
relHeader: REL_HEADER,
|
|
skippedRels: 0,
|
|
totalValidRels: 0,
|
|
});
|
|
|
|
let tmpBase: string;
|
|
let storagePath: string;
|
|
let dbPath: string;
|
|
|
|
beforeAll(async () => {
|
|
tmpBase = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-lbug-overlap-err-'));
|
|
storagePath = path.join(tmpBase, '.gitnexus');
|
|
dbPath = path.join(storagePath, 'lbug');
|
|
await fs.mkdir(dbPath, { recursive: true });
|
|
|
|
const adapter = await import('../../src/core/lbug/lbug-adapter.js');
|
|
await adapter.initLbug(dbPath);
|
|
});
|
|
|
|
afterEach(() => {
|
|
emitMock.mockReset();
|
|
});
|
|
|
|
afterAll(async () => {
|
|
try {
|
|
const adapter = await import('../../src/core/lbug/lbug-adapter.js');
|
|
await adapter.closeLbug();
|
|
} catch {
|
|
/* may already be closed */
|
|
}
|
|
if (tmpBase) {
|
|
for (let attempt = 0; attempt < 5; attempt++) {
|
|
try {
|
|
await fs.rm(tmpBase, { recursive: true, force: true });
|
|
return;
|
|
} catch {
|
|
if (attempt < 4) await new Promise((r) => setTimeout(r, 200 * (attempt + 1)));
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
describe('loadGraphToLbug overlap error paths (#2226 F1)', () => {
|
|
it.each([1000, 0])(
|
|
'retains COPY failures and rejects skipped rows with warning_limit=%i',
|
|
async (warningLimit) => {
|
|
const adapter = await import('../../src/core/lbug/lbug-adapter.js');
|
|
const { _captureLogger } = await import('../../src/core/logger.js');
|
|
const graph = buildTestGraph([], []);
|
|
emitMock.mockImplementation(
|
|
async (_g: unknown, _r: unknown, dir: string, onNodes?: (n: NodeFiles) => void) => {
|
|
await fs.mkdir(dir, { recursive: true });
|
|
const csvPath = path.join(dir, 'function.csv');
|
|
await fs.writeFile(
|
|
csvPath,
|
|
'id,name,filePath,startLine,endLine,isExported,content,description,convexEndpointFactory\n' +
|
|
'"Function:bad.ts:copy","copy","bad.ts",bad,2,false,"","",""\n',
|
|
);
|
|
const nodeFiles = new Map([['Function', { csvPath, rows: 1 }]]) as NodeFiles;
|
|
onNodes?.(nodeFiles);
|
|
return { ...emptyResult(), nodeFiles };
|
|
},
|
|
);
|
|
const capture = _captureLogger();
|
|
try {
|
|
await adapter.executeQuery(`CALL warning_limit=${warningLimit}`);
|
|
await expect(adapter.loadGraphToLbug(graph, tmpBase, storagePath)).rejects.toThrow(
|
|
/skipped/i,
|
|
);
|
|
const records = capture.records();
|
|
expect(records.some((r) => /first COPY failure/i.test(String(r.msg)))).toBe(true);
|
|
expect(records).toContainEqual(
|
|
expect.objectContaining({
|
|
expectedRows: 1,
|
|
copiedRows: 0,
|
|
skippedRows: 1,
|
|
retainedWarnings: warningLimit === 0 ? 0 : 1,
|
|
}),
|
|
);
|
|
} finally {
|
|
try {
|
|
await adapter.executeQuery('CALL warning_limit=1000');
|
|
} finally {
|
|
capture.restore();
|
|
}
|
|
}
|
|
},
|
|
);
|
|
|
|
it('relationship-emit failure with node COPY in flight surfaces the emit error and leaks no unhandled rejection', async () => {
|
|
const adapter = await import('../../src/core/lbug/lbug-adapter.js');
|
|
const graph = buildTestGraph(
|
|
[{ id: 'File:src/u1.ts', label: 'File', name: 'u1.ts', filePath: 'src/u1.ts' }],
|
|
[],
|
|
);
|
|
|
|
// emit writes a REAL node CSV (so node COPY actually runs to completion in
|
|
// flight), fires the hook to start node COPY, then throws as if the
|
|
// relationship pass blew up (EMFILE / disk-full).
|
|
emitMock.mockImplementation(
|
|
async (
|
|
_g: unknown,
|
|
_r: unknown,
|
|
dir: string,
|
|
onNodePhaseComplete?: (n: NodeFiles) => void,
|
|
) => {
|
|
await fs.mkdir(dir, { recursive: true }); // mocked emit skips the real csvDir creation
|
|
const csvPath = path.join(dir, 'file.csv');
|
|
await fs.writeFile(
|
|
csvPath,
|
|
'id,name,filePath,content\n"File:src/u1.ts","u1.ts","src/u1.ts",""\n',
|
|
);
|
|
onNodePhaseComplete?.(new Map([['File', { csvPath, rows: 1 }]]) as NodeFiles);
|
|
throw new Error('simulated rel emit failure');
|
|
},
|
|
);
|
|
|
|
const rejections: unknown[] = [];
|
|
const onUnhandled = (e: unknown): void => {
|
|
rejections.push(e);
|
|
};
|
|
process.on('unhandledRejection', onUnhandled);
|
|
try {
|
|
await expect(adapter.loadGraphToLbug(graph, tmpBase, storagePath)).rejects.toThrow(
|
|
'simulated rel emit failure',
|
|
);
|
|
// Flush the macrotask queue so any stray rejection from the in-flight
|
|
// node-COPY promise actually surfaces BEFORE we assert — otherwise the
|
|
// check passes vacuously.
|
|
await new Promise((r) => setImmediate(r));
|
|
expect(rejections).toEqual([]);
|
|
} finally {
|
|
// forks reuse the process across this file's tests — a leaked listener
|
|
// would corrupt sibling tests.
|
|
process.off('unhandledRejection', onUnhandled);
|
|
}
|
|
});
|
|
|
|
it('also logs the node-COPY error when BOTH emit and node COPY fail (emit error still wins)', async () => {
|
|
const adapter = await import('../../src/core/lbug/lbug-adapter.js');
|
|
const { _captureLogger } = await import('../../src/core/logger.js');
|
|
const graph = buildTestGraph(
|
|
[{ id: 'File:src/u1b.ts', label: 'File', name: 'u1b.ts', filePath: 'src/u1b.ts' }],
|
|
[],
|
|
);
|
|
|
|
// nodeFiles points at a MISSING csv (node COPY fails) AND emit throws.
|
|
emitMock.mockImplementation(
|
|
async (
|
|
_g: unknown,
|
|
_r: unknown,
|
|
dir: string,
|
|
onNodePhaseComplete?: (n: NodeFiles) => void,
|
|
) => {
|
|
onNodePhaseComplete?.(
|
|
new Map([['File', { csvPath: path.join(dir, 'missing-u1b.csv'), rows: 1 }]]) as NodeFiles,
|
|
);
|
|
throw new Error('simulated rel emit failure (double)');
|
|
},
|
|
);
|
|
|
|
const cap = _captureLogger();
|
|
const rejections: unknown[] = [];
|
|
const onUnhandled = (e: unknown): void => {
|
|
rejections.push(e);
|
|
};
|
|
process.on('unhandledRejection', onUnhandled);
|
|
try {
|
|
await expect(adapter.loadGraphToLbug(graph, tmpBase, storagePath)).rejects.toThrow(
|
|
'simulated rel emit failure (double)',
|
|
);
|
|
await new Promise((r) => setImmediate(r));
|
|
expect(rejections).toEqual([]);
|
|
const warned = cap
|
|
.records()
|
|
.map((rec) => (typeof rec.msg === 'string' ? rec.msg : ''))
|
|
.some((m) => m.includes('node COPY also failed'));
|
|
expect(warned).toBe(true);
|
|
} finally {
|
|
cap.restore();
|
|
process.off('unhandledRejection', onUnhandled);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('loadGraphToLbug overlap error paths (#2226 F2)', () => {
|
|
it('a node-COPY hard failure is rethrown at the FK barrier', async () => {
|
|
const adapter = await import('../../src/core/lbug/lbug-adapter.js');
|
|
const graph = buildTestGraph(
|
|
[{ id: 'File:src/u2.ts', label: 'File', name: 'u2.ts', filePath: 'src/u2.ts' }],
|
|
[],
|
|
);
|
|
|
|
// Node COPY targets a MISSING csv. This is now caught by the staging-CSV
|
|
// preflight BEFORE the engine sees it, so the message is the actionable
|
|
// "Staging CSV for File is missing …" rather than LadybugDB's bind-time
|
|
// "No file found …" (which IGNORE_ERRORS does not suppress either). What
|
|
// this test pins is unchanged and is the point: whatever the node COPY
|
|
// fails with, it is captured in nodeCopyError and RETHROWN AT THE FK
|
|
// BARRIER rather than being swallowed. Emit otherwise "succeeds"
|
|
// (returns an empty result), so the node COPY is the only failure.
|
|
emitMock.mockImplementation(
|
|
async (
|
|
_g: unknown,
|
|
_r: unknown,
|
|
dir: string,
|
|
onNodePhaseComplete?: (n: NodeFiles) => void,
|
|
) => {
|
|
onNodePhaseComplete?.(
|
|
new Map([['File', { csvPath: path.join(dir, 'missing-u2.csv'), rows: 1 }]]) as NodeFiles,
|
|
);
|
|
return emptyResult();
|
|
},
|
|
);
|
|
|
|
await expect(adapter.loadGraphToLbug(graph, tmpBase, storagePath)).rejects.toThrow(
|
|
/Staging CSV for File is missing/,
|
|
);
|
|
});
|
|
});
|