import test from 'node:test'; import assert from 'node:assert/strict'; import fs from 'node:fs'; import path from 'node:path'; import { execFileSync } from 'node:child_process'; import { createHash } from 'node:crypto'; import { ProjectIndex } from '../src/core/context/project-index.mjs'; import { fixture } from './helpers.mjs'; const setup = t => { const f = fixture(t), cacheDirectory = path.join(f.root, 'derived'); const write = (name, text) => { const filename = path.join(f.projectRoot, name); fs.mkdirSync(path.dirname(filename), { recursive: true }); fs.writeFileSync(filename, text); return filename; }; write('main.ts', 'import { value } from "./value.js";\nexport function read() { return value; }\n'); write('value.ts', 'export const value = 1;\n'); const create = (options = {}) => new ProjectIndex({ cacheDirectory, ...options }); const records = () => fs.readdirSync(cacheDirectory).filter(name => /^[a-f0-9]{64}\.json$/.test(name)); return { ...f, write, create, records, cacheDirectory }; }; test('persistent parsing is project/SHA/config bound and produces identical semantic indexes after restart', async t => { const f = setup(t), firstIndexer = f.create(), first = await firstIndexer.refresh(f.project); assert.equal(first.cache.parsedFiles, 2); assert.equal(first.cache.stored, true); assert.equal(f.records().length, 1); const second = await f.create().refresh(f.project); assert.equal(second.cache.origin, 'disk'); assert.equal(second.cache.parsedFiles, 0); assert.equal(second.cache.reusedFiles, 3); assert.equal(second.cache.sourceVerified, true); assert.equal(second.cache.verificationPasses, 2); assert.equal(second.indexFingerprint, first.indexFingerprint); assert.deepEqual(second.symbols, first.symbols); assert.deepEqual(second.imports, first.imports); assert.equal((await firstIndexer.refresh(f.project)).cache.origin, 'memory'); const otherId = await f.create().refresh({ ...f.project, id: 'different-project' }); assert.equal(otherId.cache.parsedFiles, 2); assert.notEqual(otherId.indexFingerprint, first.indexFingerprint); const options = await f.create({ maximumSymbolsPerFile: 1 }).refresh(f.project); assert.equal(options.cache.origin, 'identity-changed'); assert.equal(options.cache.parsedFiles, 2); const revision = await f.create({ parserRevision: 'next-parser' }).refresh(f.project); assert.equal(revision.cache.origin, 'identity-changed'); assert.equal(revision.cache.parsedFiles, 2); }); test('same-size restored-mtime changes, additions, renames and deletions cannot reuse stale entries or import targets', async t => { const f = setup(t), indexer = f.create(), original = await indexer.refresh(f.project); const filename = path.join(f.projectRoot, 'value.ts'), stat = fs.statSync(filename); f.write('value.ts', 'export const other = 2;\n'); fs.utimesSync(filename, stat.atime, stat.mtime); assert.equal(fs.statSync(filename).size, stat.size); assert.ok(Math.abs(fs.statSync(filename).mtimeMs - stat.mtimeMs) < 1); const changed = await indexer.refresh(f.project); assert.equal(changed.cache.invalidatedFiles, 1); assert.equal(changed.cache.parsedFiles, 1); assert.equal(changed.cache.invalidation, 'source-or-access-changed'); assert.notEqual(changed.sourceFingerprint, original.sourceFingerprint); assert.ok(changed.symbols.some(value => value.name === 'other')); assert.ok(!changed.symbols.some(value => value.name === 'value')); fs.renameSync(filename, path.join(f.projectRoot, 'moved.ts')); const renamed = await f.create().refresh(f.project); assert.equal(renamed.cache.removedFiles, 1); assert.equal(renamed.imports[0].target, null); assert.equal(renamed.cache.parsedFiles, 1); f.write('value.ts', 'export const value = 9;\n'); const added = await indexer.refresh(f.project); assert.equal(added.imports[0].target, 'value.ts'); fs.unlinkSync(path.join(f.projectRoot, 'moved.ts')); assert.equal((await indexer.refresh(f.project)).cache.removedFiles, 1); assert.equal(original.imports[0].target, 'value.ts'); assert.ok(original.symbols.some(value => value.name === 'value')); }); test('branch and commit changes invalidate even byte-identical sources', async t => { const f = setup(t), git = args => execFileSync('git', ['-C', f.projectRoot, ...args], { windowsHide: true, encoding: 'utf8' }); git(['init', '--initial-branch=main']); git(['add', '.']); git(['-c', 'user.name=QA', '-c', 'user.email=qa@local.invalid', 'commit', '-m', 'cache baseline']); const indexer = f.create(), first = await indexer.refresh(f.project); git(['switch', '-c', 'other']); const branch = await indexer.refresh(f.project); assert.equal(branch.cache.invalidation, 'identity-changed'); assert.equal(branch.cache.parsedFiles, 2); assert.equal(branch.indexFingerprint, first.indexFingerprint, 'semantic index can match while branch-specific reuse is invalidated'); git(['-c', 'user.name=QA', '-c', 'user.email=qa@local.invalid', 'commit', '--allow-empty', '-m', 'new identity']); const commit = await f.create().refresh(f.project); assert.equal(commit.cache.origin, 'identity-changed'); assert.equal(commit.cache.parsedFiles, 2); }); test('corrupt, malformed and schema-invalid records fall back to fresh parsing', async t => { const f = setup(t), first = await f.create().refresh(f.project), filename = path.join(f.cacheDirectory, f.records()[0]); fs.writeFileSync(filename, '{bad json'); const corrupt = await f.create().refresh(f.project); assert.equal(corrupt.cache.parsedFiles, 2); assert.equal(corrupt.indexFingerprint, first.indexFingerprint); const envelope = JSON.parse(fs.readFileSync(filename, 'utf8')); envelope.payload.entries.find(value => value.path === 'main.ts').symbols = [null]; envelope.sha256 = createHash('sha256').update(JSON.stringify(envelope.payload)).digest('hex'); fs.writeFileSync(filename, JSON.stringify(envelope)); const malformed = await f.create().refresh(f.project); assert.equal(malformed.cache.parsedFiles, 1); assert.equal(malformed.indexFingerprint, first.indexFingerprint); const changed = JSON.parse(fs.readFileSync(filename, 'utf8')); changed.payload.entries[0].sha256 = '0'.repeat(64); fs.writeFileSync(filename, JSON.stringify(changed)); const digest = await f.create().refresh(f.project); assert.equal(digest.cache.origin, 'corrupt'); assert.equal(digest.cache.parsedFiles, 2); }); test('disable and clear persist without touching sources, sessions, configuration or original artifacts', async t => { const f = setup(t), indexer = f.create(); await indexer.refresh(f.project); const before = fs.readFileSync(path.join(f.projectRoot, 'main.ts')), count = f.store.sessions.size, configuration = JSON.stringify(f.store.config); indexer.configure(false); assert.equal(f.create().status().enabled, false); const disabled = await indexer.refresh(f.project); assert.equal(disabled.cache.origin, 'disabled'); assert.equal(disabled.cache.parsedFiles, 2); assert.equal(indexer.projects.size, 0); indexer.configure(true); assert.equal((await indexer.refresh(f.project)).cache.origin, 'disk'); assert.equal(indexer.clear(f.project).removedProjects, 1); assert.equal(f.records().length, 0); assert.equal((await f.create().refresh(f.project)).cache.origin, 'cold'); assert.deepEqual(fs.readFileSync(path.join(f.projectRoot, 'main.ts')), before); assert.equal(f.store.sessions.size, count); assert.equal(JSON.stringify(f.store.config), configuration); }); test('cache capacity bounds disk and memory by bytes and LRU project count', async t => { const f = setup(t), indexer = f.create({ maximumProjects: 1 }); await indexer.refresh(f.project); await indexer.refresh({ ...f.project, id: 'other-id' }); assert.equal(f.records().length, 1); assert.equal(indexer.projects.size, 1); assert.equal((await indexer.refresh(f.project)).cache.origin, 'cold'); const bounded = f.create({ maximumCacheBytes: 64, maximumEntryBytes: 64 }); const index = await bounded.refresh(f.project); assert.equal(index.cache.storageReason, 'capacity'); assert.equal(bounded.projects.size, 0); assert.ok(index.symbols.length > 0, 'capacity only affects derived storage'); }); test('incomplete scans do not load or save cached entries; unavailable files leave the current result scope', async t => { const f = setup(t), indexer = f.create(); await indexer.refresh(f.project); f.write('too-large.txt', 'x'.repeat(1024 * 1024 + 1)); const partial = await indexer.refresh(f.project); assert.equal(partial.cache.origin, 'incomplete-scan'); assert.equal(partial.cache.reusedFiles, 0); assert.equal(partial.cache.stored, false); assert.equal(partial.cache.sourceVerified, false); assert.equal(indexer.projects.size, 0); fs.unlinkSync(path.join(f.projectRoot, 'too-large.txt')); const original = fs.readFileSync; t.mock.method(fs, 'readFileSync', function (filename, ...args) { if (filename === path.join(f.projectRoot, 'value.ts')) throw Object.assign(new Error('denied'), { code: 'EACCES' }); return original.call(this, filename, ...args); }); const denied = await indexer.refresh(f.project); assert.equal(denied.coverage.snapshotComplete, false); assert.ok(!denied.symbols.some(value => value.name === 'value')); assert.equal(denied.cache.reusedFiles, 0); }); test('project and cache junctions cannot expose or delete an outside directory', async t => { const f = setup(t); await f.create().refresh(f.project); const outside = path.join(f.root, 'outside'); fs.mkdirSync(outside); fs.writeFileSync(path.join(outside, 'protected.ts'), 'export const outsideOnly = 1;\n'); fs.symlinkSync(outside, path.join(f.projectRoot, 'linked'), process.platform === 'win32' ? 'junction' : 'dir'); const indexed = await f.create().refresh(f.project); assert.ok(!JSON.stringify(indexed).includes('outsideOnly')); const linkedCache = path.join(f.root, 'linked-cache'); fs.symlinkSync(outside, linkedCache, process.platform === 'win32' ? 'junction' : 'dir'); const unsafe = f.create({ cacheDirectory: linkedCache }); assert.equal(unsafe.status().enabled, false); assert.throws(() => unsafe.clear(f.project)); assert.equal(fs.readFileSync(path.join(outside, 'protected.ts'), 'utf8'), 'export const outsideOnly = 1;\n'); }); test('concurrent file changes refuse a snapshot and clear during pending work cannot repopulate it', async t => { const f = setup(t), filename = path.join(f.projectRoot, 'value.ts'), original = fs.readFileSync; let changed = false; t.mock.method(fs, 'readFileSync', function (name, ...args) { const result = original.call(this, name, ...args); if (name === filename && !changed) { changed = true; f.write('value.ts', 'export const fresh = 2;\n'); } return result; }); const indexer = f.create(); await assert.rejects(indexer.refresh(f.project), /已变化/); assert.equal(indexer.projects.size, 0); assert.equal(f.records().length, 0); t.mock.restoreAll(); const pending = indexer.refresh(f.project); assert.equal(indexer.refresh(f.project), pending); indexer.clear(f.project); const result = await pending; assert.equal(result.cache.storageReason, 'cleared-during-refresh'); assert.equal(f.records().length, 0); assert.equal(indexer.projects.size, 0); assert.ok(result.symbols.some(value => value.name === 'fresh')); }); test('file access mode changes invalidate parsed material even when bytes are unchanged', async t => { const f = setup(t), filename = path.join(f.projectRoot, 'value.ts'), indexer = f.create(); await indexer.refresh(f.project); const old = fs.statSync(filename).mode; try { fs.chmodSync(filename, 0o444); const changed = await indexer.refresh(f.project); assert.equal(changed.cache.invalidatedFiles, 1); assert.equal(changed.cache.parsedFiles, 1); } finally { fs.chmodSync(filename, old); } }); test('tracked directory replaced by a junction invalidates access scope and never uses its old cache', async t => { const f = setup(t); f.write('src/owned.ts', 'export const keepPrivate = 1;\n'); const git = args => execFileSync('git', ['-C', f.projectRoot, '-c', 'core.autocrlf=false', ...args], { windowsHide: true, encoding: 'utf8' }); git(['init', '--initial-branch=main']); git(['add', '.']); git(['-c', 'user.name=QA', '-c', 'user.email=qa@local.invalid', 'commit', '-m', 'tracked tree']); const indexer = f.create(); await indexer.refresh(f.project); fs.renameSync(path.join(f.projectRoot, 'src'), path.join(f.root, 'saved-src')); fs.symlinkSync(path.join(f.root, 'saved-src'), path.join(f.projectRoot, 'src'), process.platform === 'win32' ? 'junction' : 'dir'); const result = await indexer.refresh(f.project); assert.equal(result.cache.origin, 'incomplete-scan'); assert.equal(result.cache.sourceVerified, false); assert.equal(result.cache.reusedFiles, 0); assert.ok(!result.symbols.some(value => value.name === 'keepPrivate')); });