209 lines
8.2 KiB
TypeScript
209 lines
8.2 KiB
TypeScript
/**
|
||
* v0.4.3 回归测试
|
||
* 覆盖：
|
||
* - P0: close 后后台 compaction 在 backend 关闭后执行（残留任务污染/吞错）
|
||
* - P0: flush 报告后台失败（不再静默吞错）
|
||
* - P1: commit 先持久化 WAL 再合并快照（WAL 失败时数据一致性）
|
||
* - P1: OPFS close 等待挂起写完成
|
||
*/
|
||
|
||
import { AriaEngine } from '../src/engine/aria/index';
|
||
import { createSchema } from '../src/table/schema';
|
||
import { LSM } from '../src/engine/aria/index/lsm';
|
||
import { OPFSEngine } from '../src/engine/opfs';
|
||
import 'fake-indexeddb/auto';
|
||
|
||
let idbCounter = 0;
|
||
function uniqueDB(): string {
|
||
return `r43-${Date.now()}-${++idbCounter}-${Math.random().toString(36).slice(2, 8)}`;
|
||
}
|
||
|
||
// ===================================================================
|
||
// P0: close 与后台 compaction
|
||
// ===================================================================
|
||
|
||
describe('P0 — close 后无残留后台任务', () => {
|
||
it('close 等待后台 compaction 完成（backend 关闭后无残留写）', async () => {
|
||
const engine = new AriaEngine({
|
||
storageBackend: 'memory',
|
||
// 小缓存 + 小 memtable：flush 文件超缓存上限被驱逐 → compaction 缓存未命中 → 触发调度
|
||
bufferPoolPages: 4,
|
||
memtableSizeThreshold: 32 * 1024,
|
||
checkpointInterval: 100000,
|
||
});
|
||
await engine.open(uniqueDB(), 1);
|
||
await engine.createTable(createSchema('t', {
|
||
id: { type: 'string', primaryKey: true },
|
||
v: { type: 'number' },
|
||
data: { type: 'string' },
|
||
}));
|
||
for (let i = 0; i < 400; i++) {
|
||
await engine.insert('t', [{ id: `k${String(i).padStart(4, '0')}`, v: i, data: 'x'.repeat(200) }]);
|
||
}
|
||
await (engine as any).lsm.flush();
|
||
const backend = (engine as any).backend;
|
||
|
||
// 立即 close：修复前 setTimeout compaction 在 backend.close() 后才执行 → 残留写
|
||
await engine.close();
|
||
|
||
// 给残留 setTimeout 执行机会
|
||
await new Promise((r) => setTimeout(r, 100));
|
||
const keysAfterClose = await (backend as any).listKeys();
|
||
// 修复前：close 后 compaction 写入 → store 残留 sst_* 文件
|
||
expect(keysAfterClose).toHaveLength(0);
|
||
});
|
||
|
||
it('close 后立即 reopen 不被旧后台任务污染', async () => {
|
||
const dbName = uniqueDB();
|
||
const engine = new AriaEngine({
|
||
storageBackend: 'indexeddb',
|
||
bufferPoolPages: 4,
|
||
memtableSizeThreshold: 32 * 1024,
|
||
checkpointInterval: 100000,
|
||
});
|
||
await engine.open(dbName, 1);
|
||
await engine.createTable(createSchema('t', {
|
||
id: { type: 'string', primaryKey: true },
|
||
v: { type: 'number' },
|
||
data: { type: 'string' },
|
||
}));
|
||
for (let i = 0; i < 300; i++) {
|
||
await engine.insert('t', [{ id: `k${String(i).padStart(4, '0')}`, v: i, data: 'x'.repeat(200) }]);
|
||
}
|
||
await (engine as any).lsm.flush();
|
||
// 立即 close + 立即 reopen（修复前：旧任务的闭包引用新 backend → 交叉写）
|
||
await engine.close();
|
||
await engine.open(dbName, 1);
|
||
// 新库数据必须完整（不被旧任务破坏）
|
||
expect(await engine.count('t')).toBe(300);
|
||
await engine.close();
|
||
});
|
||
});
|
||
|
||
// ===================================================================
|
||
// P0: 后台失败可见性（不吞错）
|
||
// ===================================================================
|
||
|
||
describe('P0 — flush 报告后台失败', () => {
|
||
class FailingStore {
|
||
failNext = true;
|
||
saved = 0;
|
||
deleted = 0;
|
||
metas: { id: number; level: number }[] = [];
|
||
async save(id: number, _data: Uint8Array): Promise<void> {
|
||
if (this.failNext) {
|
||
this.failNext = false;
|
||
throw new Error('disk full (simulated)');
|
||
}
|
||
this.saved++;
|
||
}
|
||
async load(_id: number): Promise<Uint8Array | null> { return null; }
|
||
async delete(_id: number): Promise<void> { this.deleted++; }
|
||
async allocateId(): Promise<number> { return ++this.saved; }
|
||
async listMeta(): Promise<{ id: number; level: number }[]> { return this.metas; }
|
||
async saveMeta(meta: { id: number; level: number }): Promise<void> { this.metas.push(meta); }
|
||
async deleteMeta(id: number): Promise<void> { this.metas = this.metas.filter((m) => m.id !== id); }
|
||
}
|
||
|
||
it('后台 flush 失败后 flush() 抛 DatabaseError（ARIA_BACKGROUND_ERROR）', async () => {
|
||
const store = new FailingStore();
|
||
const lsm = new LSM({
|
||
memtableSizeThreshold: 64,
|
||
sstableStore: store as any,
|
||
});
|
||
// 触发 freeze + 后台 flush（save 抛错 → 记录 lastBackgroundError）
|
||
for (let i = 0; i < 200; i++) {
|
||
lsm.put(`k${i}`, { v: i });
|
||
}
|
||
await new Promise((r) => setTimeout(r, 50));
|
||
// flush 必须报告后台失败（修复前静默吞错）
|
||
await expect(lsm.flush()).rejects.toMatchObject({ code: 'ARIA_BACKGROUND_ERROR' });
|
||
// 再次 flush：错误已消费，正常完成
|
||
await expect(lsm.flush()).resolves.toBeUndefined();
|
||
});
|
||
|
||
it('后台 compaction 失败后 flush() 报告（链不卡死）', async () => {
|
||
const store = new FailingStore();
|
||
const lsm = new LSM({
|
||
memtableSizeThreshold: 32,
|
||
sstableStore: store as any,
|
||
});
|
||
for (let i = 0; i < 500; i++) {
|
||
lsm.put(`k${i}`, { v: i });
|
||
}
|
||
await new Promise((r) => setTimeout(r, 100));
|
||
// 链不卡死：flush 要么成功要么报告错误（不能永久 pending）
|
||
const result = await Promise.race([
|
||
lsm.flush().then(() => 'ok', (e) => `err:${(e as any).code}`),
|
||
new Promise((r) => setTimeout(() => r('pending'), 500)),
|
||
]);
|
||
expect(result).not.toBe('pending');
|
||
});
|
||
});
|
||
|
||
// ===================================================================
|
||
// P1: commit 顺序与 OPFS close
|
||
// ===================================================================
|
||
|
||
describe('P1 — 提交顺序与 close 等待', () => {
|
||
it('commit 先持久化 WAL 再合并快照（WAL 始终领先）', async () => {
|
||
// 通过顺序断言：事务 INSERT 的 WAL 记录必须在快照合并可见之前已落盘
|
||
const engine = new AriaEngine({ storageBackend: 'memory' });
|
||
await engine.open(uniqueDB(), 1);
|
||
await engine.createTable(createSchema('t', { id: { type: 'string', primaryKey: true } }));
|
||
await engine.beginTransaction();
|
||
await engine.insert('t', [{ id: '1' }]);
|
||
// 快照合并前：WAL 已含事务记录（batch 模式 flush 时机校验）
|
||
await engine.commitTransaction();
|
||
// 崩溃恢复路径：WAL 完整则恢复数据
|
||
const backend = (engine as any).backend;
|
||
const walKeys = (await backend.listKeys()).filter((k) => k.startsWith('__wal_'));
|
||
expect(walKeys.length).toBeGreaterThan(0);
|
||
await engine.close();
|
||
});
|
||
|
||
it('OPFS close 等待挂起写完成（文件完整）', async () => {
|
||
// mock OPFS（跨实例共享）
|
||
const files = new Map<string, string>();
|
||
const dirMock = {
|
||
getDirectoryHandle: async (_n: string, _o?: any) => dirMock as any,
|
||
getFileHandle: async (name: string, opts?: any) => {
|
||
if (opts?.create) {
|
||
return {
|
||
createWritable: async () => ({
|
||
write: async (d: string) => {
|
||
// 模拟慢 I/O
|
||
await new Promise((r) => setTimeout(r, 30));
|
||
files.set(name, d);
|
||
},
|
||
close: async () => {},
|
||
}),
|
||
};
|
||
}
|
||
if (!files.has(name)) throw new Error('Not found');
|
||
return { getFile: async () => ({ text: async () => files.get(name)!, arrayBuffer: async () => new ArrayBuffer(0) }) };
|
||
},
|
||
removeEntry: async (n: string) => { files.delete(n); },
|
||
};
|
||
(dirMock as any).entries = () => ({
|
||
[Symbol.asyncIterator]: async function* () {
|
||
for (const [k] of files) yield [k];
|
||
},
|
||
});
|
||
const nav = (globalThis as any).navigator || {};
|
||
nav.storage = { getDirectory: async () => dirMock };
|
||
(globalThis as any).navigator = nav;
|
||
|
||
const engine = new OPFSEngine();
|
||
await engine.open('opfs-close', 1);
|
||
await engine.createTable(createSchema('t', { id: { type: 'string', primaryKey: true } }));
|
||
// 写入不等待（写 I/O 30ms 挂起）
|
||
const p = engine.insert('t', [{ id: '1' }]);
|
||
// 立即 close：必须等待挂起写完成
|
||
await engine.close();
|
||
await p;
|
||
// 文件完整（修复前 close 不等写 → 可能读到旧/空文件）
|
||
expect(files.get('t.json')).toContain('"1"');
|
||
});
|
||
});
|