release: v0.5.1 — 存储后端生产级硬化（CRC-32/全库加密/WAL分片/页面化存储/多标签页锁/e2e）+ 深度审查修复（假实现接线/死代码清理）
This commit is contained in:
thzxx
@@ -113,10 +113,10 @@ describe('AriaEngine — Bloom + WAL + BufferPool', () => {
|
||||
freePageId: async (_id: number) => {},
|
||||
};
|
||||
const pool = new BufferPool(pageIO, 4);
|
||||
const page = await pool.newPage();
|
||||
expect(page.pageId).toBeGreaterThan(0);
|
||||
expect(page.pins).toBe(1);
|
||||
pool.unpin(page);
|
||||
const pages = await pool.newPages(1);
|
||||
expect(pages[0].pageId).toBeGreaterThan(0);
|
||||
expect(pages[0].pins).toBe(1);
|
||||
pool.unpin(pages[0]);
|
||||
await backend.close();
|
||||
});
|
||||
|
||||
@@ -130,11 +130,12 @@ describe('AriaEngine — Bloom + WAL + BufferPool', () => {
|
||||
freePageId: async (_id: number) => {},
|
||||
};
|
||||
const pool = new BufferPool(pageIO, 4);
|
||||
const page = await pool.newPage();
|
||||
pool.markDirty(page);
|
||||
pool.unpin(page);
|
||||
const pages = await pool.newPages(1);
|
||||
pool.markDirty(pages[0]);
|
||||
pool.unpin(pages[0]);
|
||||
await pool.flushAll();
|
||||
expect(pool.getDirtyPageCount()).toBe(0);
|
||||
const buf = await backend.read('pg_1');
|
||||
expect(buf).not.toBeNull();
|
||||
await backend.close();
|
||||
});
|
||||
});
|
||||
|
||||
+240
-273
@@ -1,273 +1,240 @@
|
||||
/**
|
||||
* AriaEngine Buffer Pool + Eviction 单元测试
|
||||
*/
|
||||
import { BufferPool, type PageIO } from '../../src/engine/aria/buffer/pool';
|
||||
import { LRUList, EvictionManager } from '../../src/engine/aria/buffer/eviction';
|
||||
import { PageType, PAGE_SIZE } from '../../src/engine/aria/types';
|
||||
import { initPageHeader } from '../../src/engine/aria/page/header';
|
||||
|
||||
// ===================================================================
|
||||
// LRUList
|
||||
// ===================================================================
|
||||
describe('AriaEngine — LRUList', () => {
|
||||
function makePage(id: number) {
|
||||
const data = new ArrayBuffer(PAGE_SIZE);
|
||||
initPageHeader(data, id, PageType.DATA);
|
||||
return { pageId: id, type: PageType.DATA, data, dirty: false, pins: 0, prev: null, next: null, lastAccess: Date.now() };
|
||||
}
|
||||
|
||||
it('moveToHead — 单元素', () => {
|
||||
const list = new LRUList();
|
||||
const p = makePage(1);
|
||||
list.moveToHead(p);
|
||||
expect(list.size).toBe(1);
|
||||
});
|
||||
|
||||
it('moveToHead — 多元素保持 MRU 顺序', () => {
|
||||
const list = new LRUList();
|
||||
const a = makePage(1);
|
||||
const b = makePage(2);
|
||||
const c = makePage(3);
|
||||
list.moveToHead(a);
|
||||
list.moveToHead(b);
|
||||
list.moveToHead(c);
|
||||
expect(list.size).toBe(3);
|
||||
// c 是最新的
|
||||
});
|
||||
|
||||
it('getLRU 返回最久未使用', () => {
|
||||
const list = new LRUList();
|
||||
const a = makePage(1);
|
||||
const b = makePage(2);
|
||||
list.moveToHead(a);
|
||||
list.moveToHead(b);
|
||||
expect(list.getLRU()!.pageId).toBe(1);
|
||||
});
|
||||
|
||||
it('popLRU 移除并返回最久未使用', () => {
|
||||
const list = new LRUList();
|
||||
const a = makePage(1);
|
||||
const b = makePage(2);
|
||||
list.moveToHead(a);
|
||||
list.moveToHead(b);
|
||||
const popped = list.popLRU();
|
||||
expect(popped!.pageId).toBe(1);
|
||||
expect(list.size).toBe(1);
|
||||
});
|
||||
|
||||
it('remove — 从中间移除', () => {
|
||||
const list = new LRUList();
|
||||
const a = makePage(1);
|
||||
const b = makePage(2);
|
||||
const c = makePage(3);
|
||||
list.moveToHead(a);
|
||||
list.moveToHead(b);
|
||||
list.moveToHead(c);
|
||||
list.remove(b);
|
||||
expect(list.size).toBe(2);
|
||||
});
|
||||
|
||||
it('clear 清空', () => {
|
||||
const list = new LRUList();
|
||||
list.moveToHead(makePage(1));
|
||||
list.moveToHead(makePage(2));
|
||||
list.clear();
|
||||
expect(list.size).toBe(0);
|
||||
});
|
||||
|
||||
it('getAllPages 返回所有页面', () => {
|
||||
const list = new LRUList();
|
||||
list.moveToHead(makePage(1));
|
||||
list.moveToHead(makePage(2));
|
||||
expect(list.getAllPages()).toHaveLength(2);
|
||||
});
|
||||
|
||||
it('空 LRU getLRU 返回 null', () => {
|
||||
const list = new LRUList();
|
||||
expect(list.getLRU()).toBeNull();
|
||||
});
|
||||
|
||||
it('空 LRU popLRU 返回 null', () => {
|
||||
const list = new LRUList();
|
||||
expect(list.popLRU()).toBeNull();
|
||||
});
|
||||
|
||||
it('moveToHead 同元素不移重复', () => {
|
||||
const list = new LRUList();
|
||||
const p = makePage(1);
|
||||
list.moveToHead(p);
|
||||
list.moveToHead(p);
|
||||
list.moveToHead(p);
|
||||
expect(list.size).toBe(1);
|
||||
});
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// EvictionManager
|
||||
// ===================================================================
|
||||
describe('AriaEngine — EvictionManager', () => {
|
||||
function makePage(id: number, dirty = false) {
|
||||
const data = new ArrayBuffer(PAGE_SIZE);
|
||||
initPageHeader(data, id, PageType.DATA);
|
||||
return { pageId: id, type: PageType.DATA, data, dirty, pins: 0, prev: null, next: null, lastAccess: Date.now() };
|
||||
}
|
||||
|
||||
it('access 更新 LRU', async () => {
|
||||
let evicted = -1;
|
||||
const em = new EvictionManager(3, async (p) => { evicted = p.pageId; });
|
||||
const p = makePage(1);
|
||||
em.add(p);
|
||||
em.access(p);
|
||||
expect(em.getSize()).toBe(1);
|
||||
});
|
||||
|
||||
it('add 不超过容量不触发驱逐', async () => {
|
||||
const evictedPages: number[] = [];
|
||||
const em = new EvictionManager(4, async (p) => { evictedPages.push(p.pageId); });
|
||||
em.add(makePage(1));
|
||||
em.add(makePage(2));
|
||||
em.add(makePage(3));
|
||||
await em.evictIfNeeded(1);
|
||||
expect(evictedPages).toHaveLength(0);
|
||||
expect(em.getSize()).toBe(3);
|
||||
});
|
||||
|
||||
it('evictIfNeeded 超容量触发驱逐', async () => {
|
||||
const evictedPages: number[] = [];
|
||||
const em = new EvictionManager(2, async (p) => { evictedPages.push(p.pageId); });
|
||||
em.add(makePage(1));
|
||||
em.add(makePage(2));
|
||||
em.add(makePage(3)); // 超容量
|
||||
await em.evictIfNeeded(0);
|
||||
// 驱逐后 size 应 <= 2
|
||||
expect(em.getSize()).toBeLessThanOrEqual(2);
|
||||
});
|
||||
|
||||
it('remove 减少 size', () => {
|
||||
const em = new EvictionManager(4, async () => {});
|
||||
const p = makePage(1);
|
||||
em.add(p);
|
||||
em.add(makePage(2));
|
||||
em.remove(p);
|
||||
expect(em.getSize()).toBe(1);
|
||||
});
|
||||
|
||||
it('getCapacity 返回配置容量', () => {
|
||||
const em = new EvictionManager(128, async () => {});
|
||||
expect(em.getCapacity()).toBe(128);
|
||||
});
|
||||
|
||||
it('clear 清空', () => {
|
||||
const em = new EvictionManager(4, async () => {});
|
||||
em.add(makePage(1));
|
||||
em.add(makePage(2));
|
||||
em.clear();
|
||||
expect(em.getSize()).toBe(0);
|
||||
});
|
||||
|
||||
it('脏页驱逐前调用 onEvict 回调', async () => {
|
||||
let flushed = 0;
|
||||
const em = new EvictionManager(2, async (_p) => { flushed++; });
|
||||
em.add(makePage(1, true)); // dirty page
|
||||
em.add(makePage(2));
|
||||
await em.evictIfNeeded(1); // need space → evict page 1
|
||||
expect(flushed).toBeGreaterThanOrEqual(0); // May or may not evict
|
||||
});
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// BufferPool (with Mock PageIO)
|
||||
// ===================================================================
|
||||
describe('AriaEngine — BufferPool', () => {
|
||||
class MockPageIO implements PageIO {
|
||||
store = new Map<number, ArrayBuffer>();
|
||||
nextId = 1;
|
||||
reads = 0;
|
||||
writes = 0;
|
||||
|
||||
async readPage(pageId: number) { this.reads++; return this.store.get(pageId) ?? null; }
|
||||
async writePage(pageId: number, data: ArrayBuffer) { this.writes++; this.store.set(pageId, data); }
|
||||
async allocatePageId() { return this.nextId++; }
|
||||
async freePageId(_pageId: number) {}
|
||||
}
|
||||
|
||||
it('newPage 创建页面并 pin', async () => {
|
||||
const io = new MockPageIO();
|
||||
const pool = new BufferPool(io, 4);
|
||||
const page = await pool.newPage();
|
||||
expect(page.pageId).toBe(1);
|
||||
expect(page.pins).toBe(1);
|
||||
expect(page.type).toBe(PageType.DATA);
|
||||
pool.unpin(page);
|
||||
});
|
||||
|
||||
it('getPage — 池中已存在则 pin++', async () => {
|
||||
const io = new MockPageIO();
|
||||
const pool = new BufferPool(io, 4);
|
||||
const p1 = await pool.newPage();
|
||||
pool.unpin(p1);
|
||||
|
||||
const p2 = await pool.getPage(p1.pageId);
|
||||
expect(p2!.pageId).toBe(p1.pageId);
|
||||
expect(p2!.pins).toBe(1);
|
||||
pool.unpin(p2!);
|
||||
});
|
||||
|
||||
it('markDirty + flushPage 写回', async () => {
|
||||
const io = new MockPageIO();
|
||||
const pool = new BufferPool(io, 4);
|
||||
const page = await pool.newPage();
|
||||
new Uint8Array(page.data)[100] = 42;
|
||||
pool.markDirty(page);
|
||||
pool.unpin(page);
|
||||
|
||||
await pool.flushPage(page.pageId);
|
||||
expect(io.writes).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it('flushAll 刷新所有脏页', async () => {
|
||||
const io = new MockPageIO();
|
||||
const pool = new BufferPool(io, 8);
|
||||
const p1 = await pool.newPage();
|
||||
const p2 = await pool.newPage();
|
||||
pool.markDirty(p1);
|
||||
pool.markDirty(p2);
|
||||
pool.unpin(p1);
|
||||
pool.unpin(p2);
|
||||
|
||||
await pool.flushAll();
|
||||
expect(io.writes).toBe(2);
|
||||
});
|
||||
|
||||
it('getCachedPageCount 返回缓存数', async () => {
|
||||
const io = new MockPageIO();
|
||||
const pool = new BufferPool(io, 4);
|
||||
await pool.newPage();
|
||||
await pool.newPage();
|
||||
expect(pool.getCachedPageCount()).toBe(2);
|
||||
});
|
||||
|
||||
it('getDirtyPageCount 返回脏页数', async () => {
|
||||
const io = new MockPageIO();
|
||||
const pool = new BufferPool(io, 4);
|
||||
const p = await pool.newPage();
|
||||
pool.markDirty(p);
|
||||
pool.unpin(p);
|
||||
expect(pool.getDirtyPageCount()).toBe(1);
|
||||
});
|
||||
|
||||
it('getCapacity 返回容量', async () => {
|
||||
const io = new MockPageIO();
|
||||
const pool = new BufferPool(io, 64);
|
||||
expect(pool.getCapacity()).toBe(64);
|
||||
});
|
||||
|
||||
it('removePage 移除缓存', async () => {
|
||||
const io = new MockPageIO();
|
||||
const pool = new BufferPool(io, 4);
|
||||
const p = await pool.newPage();
|
||||
pool.unpin(p);
|
||||
pool.removePage(p.pageId);
|
||||
expect(pool.getCachedPageCount()).toBe(0);
|
||||
});
|
||||
});
|
||||
/**
|
||||
* AriaEngine Buffer Pool + Eviction 单元测试
|
||||
*/
|
||||
import { BufferPool, type PageIO } from '../../src/engine/aria/buffer/pool';
|
||||
import { LRUList, EvictionManager } from '../../src/engine/aria/buffer/eviction';
|
||||
import { PageType, PAGE_SIZE } from '../../src/engine/aria/types';
|
||||
import { initPageHeader } from '../../src/engine/aria/page/header';
|
||||
|
||||
// ===================================================================
|
||||
// LRUList
|
||||
// ===================================================================
|
||||
describe('AriaEngine — LRUList', () => {
|
||||
function makePage(id: number) {
|
||||
const data = new ArrayBuffer(PAGE_SIZE);
|
||||
initPageHeader(data, id, PageType.DATA);
|
||||
return { pageId: id, type: PageType.DATA, data, dirty: false, pins: 0, prev: null, next: null, lastAccess: Date.now() };
|
||||
}
|
||||
|
||||
it('moveToHead — 单元素', () => {
|
||||
const list = new LRUList();
|
||||
const p = makePage(1);
|
||||
list.moveToHead(p);
|
||||
expect(list.size).toBe(1);
|
||||
});
|
||||
|
||||
it('moveToHead — 多元素保持 MRU 顺序', () => {
|
||||
const list = new LRUList();
|
||||
const a = makePage(1);
|
||||
const b = makePage(2);
|
||||
const c = makePage(3);
|
||||
list.moveToHead(a);
|
||||
list.moveToHead(b);
|
||||
list.moveToHead(c);
|
||||
expect(list.size).toBe(3);
|
||||
// c 是最新的
|
||||
});
|
||||
|
||||
it('getLRU 返回最久未使用', () => {
|
||||
const list = new LRUList();
|
||||
const a = makePage(1);
|
||||
const b = makePage(2);
|
||||
list.moveToHead(a);
|
||||
list.moveToHead(b);
|
||||
expect(list.getLRU()!.pageId).toBe(1);
|
||||
});
|
||||
|
||||
it('remove — 从中间移除', () => {
|
||||
const list = new LRUList();
|
||||
const a = makePage(1);
|
||||
const b = makePage(2);
|
||||
const c = makePage(3);
|
||||
list.moveToHead(a);
|
||||
list.moveToHead(b);
|
||||
list.moveToHead(c);
|
||||
list.remove(b);
|
||||
expect(list.size).toBe(2);
|
||||
});
|
||||
|
||||
it('clear 清空', () => {
|
||||
const list = new LRUList();
|
||||
list.moveToHead(makePage(1));
|
||||
list.moveToHead(makePage(2));
|
||||
list.clear();
|
||||
expect(list.size).toBe(0);
|
||||
});
|
||||
|
||||
it('remove 从尾部移除', () => {
|
||||
const list = new LRUList();
|
||||
const a = makePage(1);
|
||||
list.moveToHead(a);
|
||||
list.remove(a);
|
||||
expect(list.size).toBe(0);
|
||||
});
|
||||
|
||||
it('空 LRU getLRU 返回 null', () => {
|
||||
const list = new LRUList();
|
||||
expect(list.getLRU()).toBeNull();
|
||||
});
|
||||
|
||||
it('moveToHead 同元素不移重复', () => {
|
||||
const list = new LRUList();
|
||||
const p = makePage(1);
|
||||
list.moveToHead(p);
|
||||
list.moveToHead(p);
|
||||
list.moveToHead(p);
|
||||
expect(list.size).toBe(1);
|
||||
});
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// EvictionManager
|
||||
// ===================================================================
|
||||
describe('AriaEngine — EvictionManager', () => {
|
||||
function makePage(id: number, dirty = false) {
|
||||
const data = new ArrayBuffer(PAGE_SIZE);
|
||||
initPageHeader(data, id, PageType.DATA);
|
||||
return { pageId: id, type: PageType.DATA, data, dirty, pins: 0, prev: null, next: null, lastAccess: Date.now() };
|
||||
}
|
||||
|
||||
it('access 更新 LRU', async () => {
|
||||
let evicted = -1;
|
||||
const em = new EvictionManager(3, async (p) => { evicted = p.pageId; });
|
||||
const p = makePage(1);
|
||||
em.add(p);
|
||||
em.access(p);
|
||||
expect((em as unknown as { lru: { size: number } }).lru.size).toBe(1);
|
||||
});
|
||||
|
||||
it('add 不超过容量不触发驱逐', async () => {
|
||||
const evictedPages: number[] = [];
|
||||
const em = new EvictionManager(4, async (p) => { evictedPages.push(p.pageId); });
|
||||
em.add(makePage(1));
|
||||
em.add(makePage(2));
|
||||
em.add(makePage(3));
|
||||
await em.evictIfNeeded(1);
|
||||
expect(evictedPages).toHaveLength(0);
|
||||
expect((em as unknown as { lru: { size: number } }).lru.size).toBe(3);
|
||||
});
|
||||
|
||||
it('evictIfNeeded 超容量触发驱逐', async () => {
|
||||
const evictedPages: number[] = [];
|
||||
const em = new EvictionManager(2, async (p) => { evictedPages.push(p.pageId); });
|
||||
em.add(makePage(1));
|
||||
em.add(makePage(2));
|
||||
em.add(makePage(3)); // 超容量
|
||||
await em.evictIfNeeded(0);
|
||||
// 驱逐后 size 应 <= 2
|
||||
expect((em as unknown as { lru: { size: number } }).lru.size).toBeLessThanOrEqual(2);
|
||||
});
|
||||
|
||||
it('remove 减少 size', () => {
|
||||
const em = new EvictionManager(4, async () => {});
|
||||
const p = makePage(1);
|
||||
em.add(p);
|
||||
em.add(makePage(2));
|
||||
em.remove(p);
|
||||
expect((em as unknown as { lru: { size: number } }).lru.size).toBe(1);
|
||||
});
|
||||
|
||||
it('clear 清空', () => {
|
||||
const em = new EvictionManager(4, async () => {});
|
||||
em.add(makePage(1));
|
||||
em.add(makePage(2));
|
||||
em.clear();
|
||||
expect((em as unknown as { lru: { size: number } }).lru.size).toBe(0);
|
||||
});
|
||||
|
||||
it('脏页驱逐前调用 onEvict 回调', async () => {
|
||||
let flushed = 0;
|
||||
const em = new EvictionManager(2, async (_p) => { flushed++; });
|
||||
em.add(makePage(1, true)); // dirty page
|
||||
em.add(makePage(2));
|
||||
await em.evictIfNeeded(1); // need space → evict page 1
|
||||
expect(flushed).toBeGreaterThanOrEqual(0); // May or may not evict
|
||||
});
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// BufferPool (with Mock PageIO)
|
||||
// ===================================================================
|
||||
describe('AriaEngine — BufferPool', () => {
|
||||
class MockPageIO implements PageIO {
|
||||
store = new Map<number, ArrayBuffer>();
|
||||
nextId = 1;
|
||||
reads = 0;
|
||||
writes = 0;
|
||||
|
||||
async readPage(pageId: number) { this.reads++; return this.store.get(pageId) ?? null; }
|
||||
async writePage(pageId: number, data: ArrayBuffer) { this.writes++; this.store.set(pageId, data); }
|
||||
async allocatePageId() { return this.nextId++; }
|
||||
async freePageId(_pageId: number) {}
|
||||
}
|
||||
|
||||
it('newPage 创建页面并 pin', async () => {
|
||||
const io = new MockPageIO();
|
||||
const pool = new BufferPool(io, 4);
|
||||
const page = (await pool.newPages(1))[0];
|
||||
expect(page.pageId).toBe(1);
|
||||
expect(page.pins).toBe(1);
|
||||
expect(page.type).toBe(PageType.DATA);
|
||||
pool.unpin(page);
|
||||
});
|
||||
|
||||
it('getPage — 池中已存在则 pin++', async () => {
|
||||
const io = new MockPageIO();
|
||||
const pool = new BufferPool(io, 4);
|
||||
const p1 = (await pool.newPages(1))[0];
|
||||
pool.unpin(p1);
|
||||
|
||||
const p2 = await pool.getPage(p1.pageId);
|
||||
expect(p2!.pageId).toBe(p1.pageId);
|
||||
expect(p2!.pins).toBe(1);
|
||||
pool.unpin(p2!);
|
||||
});
|
||||
|
||||
it('markDirty + flushPage 写回', async () => {
|
||||
const io = new MockPageIO();
|
||||
const pool = new BufferPool(io, 4);
|
||||
const page = (await pool.newPages(1))[0];
|
||||
new Uint8Array(page.data)[100] = 42;
|
||||
pool.markDirty(page);
|
||||
pool.unpin(page);
|
||||
|
||||
await pool.flushPage(page.pageId);
|
||||
expect(io.writes).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it('flushAll 刷新所有脏页', async () => {
|
||||
const io = new MockPageIO();
|
||||
const pool = new BufferPool(io, 8);
|
||||
const p1 = (await pool.newPages(1))[0];
|
||||
const p2 = (await pool.newPages(1))[0];
|
||||
pool.markDirty(p1);
|
||||
pool.markDirty(p2);
|
||||
pool.unpin(p1);
|
||||
pool.unpin(p2);
|
||||
|
||||
await pool.flushAll();
|
||||
expect(io.writes).toBe(2);
|
||||
});
|
||||
|
||||
it('newPages 批量创建页面并 pin', async () => {
|
||||
const io = new MockPageIO();
|
||||
const pool = new BufferPool(io, 8);
|
||||
const pages = await pool.newPages(3);
|
||||
expect(pages.map((p) => p.pageId)).toEqual([1, 2, 3]);
|
||||
expect(pages.every((p) => p.pins === 1)).toBe(true);
|
||||
expect(pages.every((p) => p.type === PageType.DATA)).toBe(true);
|
||||
for (const p of pages) pool.unpin(p);
|
||||
});
|
||||
|
||||
it('removePage 移除缓存', async () => {
|
||||
const io = new MockPageIO();
|
||||
const pool = new BufferPool(io, 4);
|
||||
const p = (await pool.newPages(1))[0];
|
||||
pool.unpin(p);
|
||||
pool.removePage(p.pageId);
|
||||
expect((pool as unknown as { pages: Map<number, unknown> }).pages.size).toBe(0);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -53,7 +53,7 @@ describe('AriaEngine SSTable 缓存内存上限', () => {
|
||||
for (let round = 0; round < 5; round++) {
|
||||
const rows = await engine.find('users', { table: 'users', where: { age: 25 } });
|
||||
expect(rows.length).toBe(10);
|
||||
expect(lsm.getCacheSize()).toBeLessThanOrEqual(lsm.getCacheLimit());
|
||||
expect(lsm.cacheSize).toBeLessThanOrEqual(lsm.cacheLimitBytes);
|
||||
}
|
||||
|
||||
await engine.close();
|
||||
@@ -74,7 +74,7 @@ describe('AriaEngine SSTable 缓存内存上限', () => {
|
||||
expect(all.length).toBe(300);
|
||||
|
||||
const lsm = (engine as any).lsm;
|
||||
expect(lsm.getCacheSize()).toBeLessThanOrEqual(lsm.getCacheLimit());
|
||||
expect(lsm.cacheSize).toBeLessThanOrEqual(lsm.cacheLimitBytes);
|
||||
await engine.close();
|
||||
});
|
||||
|
||||
@@ -165,7 +165,7 @@ describe('AriaEngine SSTable 缓存内存上限', () => {
|
||||
for (let batch = 0; batch < 10; batch++) {
|
||||
await engine.insert('users', makeRows(30).map((r, i) => ({ ...r, id: `b${batch}_u${i}` })));
|
||||
const lsm = (engine as any).lsm;
|
||||
expect(lsm.getCacheSize()).toBeLessThanOrEqual(lsm.getCacheLimit());
|
||||
expect(lsm.cacheSize).toBeLessThanOrEqual(lsm.cacheLimitBytes);
|
||||
}
|
||||
|
||||
const all = await engine.find('users', { table: 'users' });
|
||||
|
||||
@@ -0,0 +1,181 @@
|
||||
/**
|
||||
* AriaEngine — SSTable CRC-32 损坏检测集成测试
|
||||
*
|
||||
* 覆盖：
|
||||
* 1. 打开时整文件 CRC 校验失败 → 损坏 SSTable 被清理（自愈），打开不阻塞
|
||||
* 2. 运行期预加载 CRC 校验失败 → 损坏文件不缓存并被清理
|
||||
* 3. 旧版无校验文件（checksum=0）在 LSM 层仍正常加载
|
||||
*/
|
||||
import { AriaEngine } from '../../src/engine/aria/index';
|
||||
import { createSchema } from '../../src/table/schema';
|
||||
import 'fake-indexeddb/auto';
|
||||
|
||||
let idbCounter = 0;
|
||||
function uniqueDB(): string {
|
||||
return `crc-${Date.now()}-${++idbCounter}-${Math.random().toString(36).slice(2, 8)}`;
|
||||
}
|
||||
|
||||
const SCHEMA = () => createSchema('users', {
|
||||
id: { type: 'string', primaryKey: true },
|
||||
name: { type: 'string' },
|
||||
age: { type: 'number' },
|
||||
});
|
||||
|
||||
/** 篡改 MemoryBackend 中指定 key 的一个字节 */
|
||||
async function corruptKey(engine: AriaEngine, key: string, byteOffset: number): Promise<void> {
|
||||
const backend = (engine as any).backend;
|
||||
const raw = await backend.read(key);
|
||||
expect(raw).not.toBeNull();
|
||||
const buf = new Uint8Array(raw as ArrayBuffer);
|
||||
buf[Math.min(byteOffset, buf.length - 1)] ^= 0xff;
|
||||
await backend.write(key, buf.buffer as ArrayBuffer);
|
||||
}
|
||||
|
||||
/** 列出 backend 中所有 sst_ 前缀 key */
|
||||
async function listSSTKeys(engine: AriaEngine): Promise<string[]> {
|
||||
const backend = (engine as any).backend;
|
||||
const keys = await backend.listKeys();
|
||||
return (keys as string[]).filter((k) => k.startsWith('sst_'));
|
||||
}
|
||||
|
||||
describe('AriaEngine — SSTable CRC 损坏检测（集成）', () => {
|
||||
it('打开时 CRC 损坏的 SSTable 被清理，其余数据可读', async () => {
|
||||
const engine = new AriaEngine({ storageBackend: 'indexeddb', memtableSizeThreshold: 64 * 1024 * 1024 });
|
||||
const dbName = uniqueDB();
|
||||
await engine.open(dbName, 1);
|
||||
await engine.createTable(SCHEMA());
|
||||
|
||||
// 写入 200 行（触发多次 flush → 多个 SSTable）
|
||||
for (let batch = 0; batch < 3; batch++) {
|
||||
const rows = [] as Record<string, unknown>[];
|
||||
for (let i = 0; i < 50; i++) {
|
||||
rows.push({ id: `u-${batch * 50 + i}`, name: `User${batch * 50 + i}`, age: batch * 50 + i });
|
||||
}
|
||||
await engine.insert('users', rows);
|
||||
await (engine as any).lsm.flush();
|
||||
}
|
||||
await engine.close();
|
||||
|
||||
// 重新打开，篡改第一个 SSTable 文件的数据区
|
||||
const engine2 = new AriaEngine({ storageBackend: 'indexeddb', memtableSizeThreshold: 64 * 1024 * 1024 });
|
||||
await engine2.open(dbName, 1);
|
||||
const sstKeys = await listSSTKeys(engine2);
|
||||
expect(sstKeys.length).toBeGreaterThanOrEqual(2);
|
||||
await corruptKey(engine2, sstKeys[0], 64);
|
||||
|
||||
// 再次打开：损坏文件应被跳过并清理，打开不抛错
|
||||
await engine2.close();
|
||||
const engine3 = new AriaEngine({ storageBackend: 'indexeddb', memtableSizeThreshold: 64 * 1024 * 1024 });
|
||||
await engine3.open(dbName, 1);
|
||||
|
||||
// 剩余未损坏文件的数据应可查询
|
||||
const remaining = await engine3.find('users', { table: 'users' });
|
||||
expect(remaining.length).toBeGreaterThan(0);
|
||||
expect(remaining.length).toBeLessThan(200);
|
||||
|
||||
// 损坏文件已被清理（meta 移除）
|
||||
const afterKeys = await listSSTKeys(engine3);
|
||||
expect(afterKeys).not.toContain(sstKeys[0]);
|
||||
const lsm = (engine3 as any).lsm;
|
||||
const metas = await lsm.sstableStore.listMeta();
|
||||
expect(metas.some((m: { id: number }) => m.id === Number(sstKeys[0].replace('sst_', '')))).toBe(false);
|
||||
|
||||
await engine3.close();
|
||||
});
|
||||
|
||||
it('打开时损坏全部 SSTable → 库仍可打开，数据为空但不崩溃', async () => {
|
||||
const engine = new AriaEngine({ storageBackend: 'indexeddb', memtableSizeThreshold: 64 * 1024 * 1024 });
|
||||
const dbName = uniqueDB();
|
||||
await engine.open(dbName, 1);
|
||||
await engine.createTable(SCHEMA());
|
||||
for (let batch = 0; batch < 2; batch++) {
|
||||
const rows = [] as Record<string, unknown>[];
|
||||
for (let i = 0; i < 50; i++) {
|
||||
rows.push({ id: `u-${batch * 50 + i}`, name: `User${batch * 50 + i}`, age: batch * 50 + i });
|
||||
}
|
||||
await engine.insert('users', rows);
|
||||
await (engine as any).lsm.flush();
|
||||
}
|
||||
await engine.close();
|
||||
|
||||
const engine2 = new AriaEngine({ storageBackend: 'indexeddb', memtableSizeThreshold: 64 * 1024 * 1024 });
|
||||
await engine2.open(dbName, 1);
|
||||
for (const key of await listSSTKeys(engine2)) {
|
||||
await corruptKey(engine2, key, 16);
|
||||
}
|
||||
await engine2.close();
|
||||
|
||||
const engine3 = new AriaEngine({ storageBackend: 'indexeddb', memtableSizeThreshold: 64 * 1024 * 1024 });
|
||||
// 不应抛 ARIA_OPEN_ERROR
|
||||
await engine3.open(dbName, 1);
|
||||
const rows3 = await engine3.find('users', { table: 'users' });
|
||||
expect(rows3.length).toBe(0);
|
||||
await engine3.close();
|
||||
});
|
||||
|
||||
it('运行期 CRC 损坏 → 预加载不缓存损坏文件并清理（自愈）', async () => {
|
||||
const engine = new AriaEngine({ storageBackend: 'indexeddb', memtableSizeThreshold: 64 * 1024 * 1024 });
|
||||
const dbName = uniqueDB();
|
||||
await engine.open(dbName, 1);
|
||||
await engine.createTable(SCHEMA());
|
||||
for (let batch = 0; batch < 2; batch++) {
|
||||
const rows = [] as Record<string, unknown>[];
|
||||
for (let i = 0; i < 50; i++) {
|
||||
rows.push({ id: `u-${batch * 50 + i}`, name: `User${batch * 50 + i}`, age: batch * 50 + i });
|
||||
}
|
||||
await engine.insert('users', rows);
|
||||
await (engine as any).lsm.flush();
|
||||
}
|
||||
|
||||
// 运行期：直接篡改后端中的某个 SSTable 文件（不触发打开校验路径）
|
||||
const sstKeys = await listSSTKeys(engine);
|
||||
expect(sstKeys.length).toBeGreaterThanOrEqual(2);
|
||||
const victim = sstKeys[sstKeys.length - 1]; // 篡改最新（memtable 已 flush 后的文件）
|
||||
await corruptKey(engine, victim, 100);
|
||||
|
||||
// 缓存里已有该文件（flush 时缓存）→ 先清缓存模拟运行期重载
|
||||
const lsm = (engine as any).lsm;
|
||||
lsm.sstableCache.delete(Number(victim.replace('sst_', '')));
|
||||
|
||||
// 查询触发 prefetchRange → preloadSSTable 发现 CRC 失败 → 清理 + 不缓存
|
||||
const remaining = await engine.find('users', { table: 'users' });
|
||||
expect(remaining.length).toBeLessThan(100);
|
||||
expect(lsm.sstableCache.has(Number(victim.replace('sst_', '')))).toBe(false);
|
||||
const metas = await lsm.sstableStore.listMeta();
|
||||
expect(metas.some((m: { id: number }) => m.id === Number(victim.replace('sst_', '')))).toBe(false);
|
||||
|
||||
await engine.close();
|
||||
});
|
||||
|
||||
it('旧版无校验文件（checksum=0）在 LSM 中正常加载', async () => {
|
||||
const engine = new AriaEngine({ storageBackend: 'indexeddb', memtableSizeThreshold: 64 * 1024 * 1024 });
|
||||
const dbName = uniqueDB();
|
||||
await engine.open(dbName, 1);
|
||||
await engine.createTable(SCHEMA());
|
||||
await engine.insert('users', [
|
||||
{ id: 'a', name: 'Alice', age: 30 },
|
||||
{ id: 'b', name: 'Bob', age: 25 },
|
||||
]);
|
||||
await (engine as any).lsm.flush();
|
||||
await engine.close();
|
||||
|
||||
const engine2 = new AriaEngine({ storageBackend: 'indexeddb', memtableSizeThreshold: 64 * 1024 * 1024 });
|
||||
await engine2.open(dbName, 1);
|
||||
const sstKeys = await listSSTKeys(engine2);
|
||||
expect(sstKeys.length).toBe(1);
|
||||
const backend = (engine2 as any).backend;
|
||||
const raw = await backend.read(sstKeys[0]);
|
||||
const buf = new Uint8Array(raw as ArrayBuffer);
|
||||
new DataView(buf.buffer).setUint32(buf.byteLength - 4, 0, false); // checksum 清零 → 旧版
|
||||
await backend.write(sstKeys[0], buf.buffer as ArrayBuffer);
|
||||
await engine2.close();
|
||||
|
||||
// 重开：checksum=0 跳过校验，数据完整可读
|
||||
const engine3 = new AriaEngine({ storageBackend: 'indexeddb', memtableSizeThreshold: 64 * 1024 * 1024 });
|
||||
await engine3.open(dbName, 1);
|
||||
const rows3 = await engine3.find('users', { table: 'users' });
|
||||
expect(rows3.length).toBe(2);
|
||||
expect(rows3.map((r) => r.id).sort()).toEqual(['a', 'b']);
|
||||
await engine3.close();
|
||||
});
|
||||
});
|
||||
+250
-218
@@ -1,218 +1,250 @@
|
||||
/**
|
||||
* AriaEngine LZ4 压缩 + LSM Merge Iterator 单元测试
|
||||
* 注：LZ4 为简化演示实现（默认 compression:false），测试聚焦于「不卡死」
|
||||
*/
|
||||
import { compressLZ4, decompressLZ4 } from '../../src/engine/aria/compression/lz4';
|
||||
import { MergeIterator, ArrayEntrySource } from '../../src/engine/aria/index/merge_iterator';
|
||||
|
||||
// ===================================================================
|
||||
// LZ4 压缩 — 安全烟雾测试（不卡死）
|
||||
// ===================================================================
|
||||
describe('AriaEngine — LZ4 Compression', () => {
|
||||
it('短于 4 字节时压缩为纯字面量 token 且往返一致', () => {
|
||||
const input = new Uint8Array([1, 2]);
|
||||
const compressed = compressLZ4(input);
|
||||
// token(lo=0) + 2 字节字面量
|
||||
expect(compressed.byteLength).toBe(3);
|
||||
expect(compressed[0]).toBe(0x20); // litLen=2, matchField=0
|
||||
const restored = decompressLZ4(compressed, 2);
|
||||
expect(Array.from(restored)).toEqual([1, 2]);
|
||||
});
|
||||
|
||||
it('简单文本压缩不抛出异常且产生输出', () => {
|
||||
const input = new TextEncoder().encode('hello world hello world hello world');
|
||||
const compressed = compressLZ4(input);
|
||||
expect(compressed).toBeInstanceOf(Uint8Array);
|
||||
expect(compressed.byteLength).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it('重复数据有压缩效果', () => {
|
||||
const pattern = 'ABCD';
|
||||
const repeated = pattern.repeat(100);
|
||||
const input = new TextEncoder().encode(repeated);
|
||||
const compressed = compressLZ4(input);
|
||||
expect(compressed.byteLength).toBeLessThan(input.byteLength);
|
||||
});
|
||||
|
||||
it('随机不可压缩数据不卡死', () => {
|
||||
const input = new Uint8Array(256);
|
||||
for (let i = 0; i < 256; i++) input[i] = Math.floor(Math.random() * 256);
|
||||
const compressed = compressLZ4(input);
|
||||
expect(compressed).toBeInstanceOf(Uint8Array);
|
||||
expect(compressed.byteLength).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it('长文本压缩不卡死', () => {
|
||||
const input = new TextEncoder().encode('The quick brown fox jumps over the lazy dog. '.repeat(10));
|
||||
const compressed = compressLZ4(input);
|
||||
expect(compressed).toBeTruthy();
|
||||
expect(compressed.byteLength).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it('多种长度输入均不卡死', () => {
|
||||
for (const size of [10, 50, 100, 200, 500]) {
|
||||
const input = new Uint8Array(size);
|
||||
for (let i = 0; i < size; i++) input[i] = i % 256;
|
||||
const compressed = compressLZ4(input);
|
||||
expect(compressed.byteLength).toBeLessThanOrEqual(input.byteLength + 16);
|
||||
}
|
||||
});
|
||||
|
||||
it('解压不抛出异常', () => {
|
||||
const input = new TextEncoder().encode('test data for decompression smoke test');
|
||||
const compressed = compressLZ4(input);
|
||||
expect(() => decompressLZ4(compressed, input.byteLength)).not.toThrow();
|
||||
});
|
||||
|
||||
// ---- v0.2.6 补强：压缩 → 解压 往返一致性 ----
|
||||
|
||||
it('往返一致：重复模式数据', () => {
|
||||
const input = new TextEncoder().encode('ABCD'.repeat(100));
|
||||
const compressed = compressLZ4(input);
|
||||
const restored = decompressLZ4(compressed, input.byteLength);
|
||||
expect(Array.from(restored)).toEqual(Array.from(input));
|
||||
});
|
||||
|
||||
it('往返一致：自然文本数据', () => {
|
||||
const input = new TextEncoder().encode(
|
||||
'The quick brown fox jumps over the lazy dog. '.repeat(10),
|
||||
);
|
||||
const compressed = compressLZ4(input);
|
||||
const restored = decompressLZ4(compressed, input.byteLength);
|
||||
expect(Array.from(restored)).toEqual(Array.from(input));
|
||||
});
|
||||
|
||||
it('往返一致：随机不可压缩数据', () => {
|
||||
const input = new Uint8Array(512);
|
||||
for (let i = 0; i < 512; i++) input[i] = Math.floor(Math.random() * 256);
|
||||
const compressed = compressLZ4(input);
|
||||
const restored = decompressLZ4(compressed, input.byteLength);
|
||||
expect(Array.from(restored)).toEqual(Array.from(input));
|
||||
});
|
||||
|
||||
it('往返一致：多种长度与字节模式', () => {
|
||||
for (const size of [4, 5, 15, 16, 17, 50, 100, 300, 1000]) {
|
||||
const input = new Uint8Array(size);
|
||||
for (let i = 0; i < size; i++) input[i] = i % 7 === 0 ? i % 256 : 0x41;
|
||||
const compressed = compressLZ4(input);
|
||||
const restored = decompressLZ4(compressed, input.byteLength);
|
||||
expect(Array.from(restored)).toEqual(Array.from(input));
|
||||
}
|
||||
});
|
||||
|
||||
it('往返一致：恰好 15 字节字面量边界', () => {
|
||||
// 字面量长度恰好 15（token 上限）时不应丢字节
|
||||
const input = new Uint8Array(15);
|
||||
for (let i = 0; i < 15; i++) input[i] = i;
|
||||
const compressed = compressLZ4(input);
|
||||
const restored = decompressLZ4(compressed, input.byteLength);
|
||||
expect(Array.from(restored)).toEqual(Array.from(input));
|
||||
});
|
||||
|
||||
it('往返一致：超过 15 字节的连续匹配', () => {
|
||||
const input = new TextEncoder().encode('X'.repeat(200) + 'Y' + 'X'.repeat(60));
|
||||
const compressed = compressLZ4(input);
|
||||
const restored = decompressLZ4(compressed, input.byteLength);
|
||||
expect(Array.from(restored)).toEqual(Array.from(input));
|
||||
});
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// MergeIterator — 归并迭代器单元测试
|
||||
// ===================================================================
|
||||
describe('AriaEngine — MergeIterator', () => {
|
||||
it('单数据源归并', () => {
|
||||
const mi = new MergeIterator();
|
||||
mi.addSource(new ArrayEntrySource([
|
||||
['a', { v: 1 }],
|
||||
['b', { v: 2 }],
|
||||
['c', { v: 3 }],
|
||||
]));
|
||||
const result = mi.drain();
|
||||
expect(result).toHaveLength(3);
|
||||
expect(result.map(([k]) => k)).toEqual(['a', 'b', 'c']);
|
||||
});
|
||||
|
||||
it('多数据源归并去重（保留最新）', () => {
|
||||
const mi = new MergeIterator();
|
||||
mi.addSource(new ArrayEntrySource([['a', { v: 'new' }], ['c', { v: 3 }]]));
|
||||
mi.addSource(new ArrayEntrySource([['a', { v: 'old' }], ['b', { v: 2 }]]));
|
||||
const result = mi.drain();
|
||||
expect(result).toHaveLength(3);
|
||||
expect(result[0][0]).toBe('a');
|
||||
expect(result[0][1].v).toBe('new');
|
||||
expect(result[1][0]).toBe('b');
|
||||
expect(result[2][0]).toBe('c');
|
||||
});
|
||||
|
||||
// ---- v0.2.6 回归：同 key 多来源时保留 sourceIndex 最小（最新）的条目 ----
|
||||
it('回归：同 key 出现在多个来源时返回 sourceIndex 最小（最新来源）的值', () => {
|
||||
const mi = new MergeIterator();
|
||||
// 语义：sourceIndex 越小越新（memtable=0 < immutable=1 < sstable=2+）
|
||||
mi.addSource(new ArrayEntrySource([['a', { v: 'source0' }]])); // 最新来源
|
||||
mi.addSource(new ArrayEntrySource([['a', { v: 'source1' }]]));
|
||||
mi.addSource(new ArrayEntrySource([['a', { v: 'source2' }]])); // 最旧来源
|
||||
const result = mi.drain();
|
||||
expect(result).toHaveLength(1);
|
||||
// 取的是 sourceIndex 最小（最新来源）的条目，而非堆序决定的任意条目
|
||||
expect(result[0][1].v).toBe('source0');
|
||||
});
|
||||
|
||||
it('回归：最新来源的值位于中间 sourceIndex 时仍取 sourceIndex 最小者', () => {
|
||||
const mi = new MergeIterator();
|
||||
mi.addSource(new ArrayEntrySource([['a', { v: 'middle' }]])); // index 0 = 最新来源
|
||||
mi.addSource(new ArrayEntrySource([['a', { v: 'newest' }]])); // index 1
|
||||
mi.addSource(new ArrayEntrySource([['a', { v: 'oldest' }]])); // index 2
|
||||
const result = mi.drain();
|
||||
expect(result).toHaveLength(1);
|
||||
expect(result[0][1].v).toBe('middle'); // index 0 的条目胜出
|
||||
});
|
||||
|
||||
it('回归：多个同 key 来源 + 其他独立 key 混合', () => {
|
||||
const mi = new MergeIterator();
|
||||
mi.addSource(new ArrayEntrySource([['a', { v: 1 }], ['b', { v: 10 }]]));
|
||||
mi.addSource(new ArrayEntrySource([['a', { v: 2 }]]));
|
||||
mi.addSource(new ArrayEntrySource([['a', { v: 3 }], ['c', { v: 30 }]]));
|
||||
const result = mi.drain();
|
||||
expect(result.map(([k]) => k)).toEqual(['a', 'b', 'c']);
|
||||
expect(result[0][1].v).toBe(1); // sourceIndex 0 = 最新
|
||||
expect(result[1][1].v).toBe(10);
|
||||
expect(result[2][1].v).toBe(30);
|
||||
});
|
||||
|
||||
it('空数据源归并', () => {
|
||||
const mi = new MergeIterator();
|
||||
mi.addSource(new ArrayEntrySource([]));
|
||||
const result = mi.drain();
|
||||
expect(result).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('大数量归并', () => {
|
||||
const mi = new MergeIterator();
|
||||
for (let s = 0; s < 5; s++) {
|
||||
const entries: [string, Record<string, unknown>][] = [];
|
||||
for (let i = 0; i < 100; i++) {
|
||||
entries.push([`src${s}-key-${String(i).padStart(3, '0')}`, { src: s, idx: i }]);
|
||||
}
|
||||
mi.addSource(new ArrayEntrySource(entries));
|
||||
}
|
||||
const result = mi.drain();
|
||||
// 5 sources × 100 unique keys = 500 total (keys are unique per source)
|
||||
expect(result).toHaveLength(500);
|
||||
});
|
||||
|
||||
it('ArrayEntrySource — 迭代器用完返回 null', () => {
|
||||
const src = new ArrayEntrySource([['k', { v: 1 }]]);
|
||||
expect(src.next()).not.toBeNull();
|
||||
expect(src.next()).toBeNull();
|
||||
expect(src.next()).toBeNull();
|
||||
});
|
||||
|
||||
it('ArrayEntrySource — reset 重置', () => {
|
||||
const src = new ArrayEntrySource([['k1', { v: 1 }], ['k2', { v: 2 }]]);
|
||||
src.next();
|
||||
src.reset();
|
||||
const val = src.next();
|
||||
expect(val![0]).toBe('k1');
|
||||
});
|
||||
});
|
||||
/**
|
||||
* AriaEngine LZ4 压缩 + LSM Merge Iterator 单元测试
|
||||
* 注：LZ4 为简化演示实现（默认 compression:false），测试聚焦于「不卡死」
|
||||
*/
|
||||
import { compressLZ4, decompressLZ4 } from '../../src/engine/aria/compression/lz4';
|
||||
import { MergeIterator, ArrayEntrySource } from '../../src/engine/aria/index/merge_iterator';
|
||||
|
||||
// ===================================================================
|
||||
// LZ4 压缩 — 安全烟雾测试（不卡死）
|
||||
// ===================================================================
|
||||
describe('AriaEngine — LZ4 Compression', () => {
|
||||
it('短于 4 字节时压缩为纯字面量 token 且往返一致（v0.4.5 带 4 字节原始大小头）', () => {
|
||||
const input = new Uint8Array([1, 2]);
|
||||
const compressed = compressLZ4(input);
|
||||
// HEADER(4) + token(lo=0) + 2 字节字面量
|
||||
expect(compressed.byteLength).toBe(7);
|
||||
// 头部 = 原始大小 2（LE）
|
||||
expect(new DataView(compressed.buffer).getUint32(0, true)).toBe(2);
|
||||
expect(compressed[4]).toBe(0x20); // litLen=2, matchField=0
|
||||
const restored = decompressLZ4(compressed, 2);
|
||||
expect(Array.from(restored)).toEqual([1, 2]);
|
||||
});
|
||||
|
||||
it('简单文本压缩不抛出异常且产生输出', () => {
|
||||
const input = new TextEncoder().encode('hello world hello world hello world');
|
||||
const compressed = compressLZ4(input);
|
||||
expect(compressed).toBeInstanceOf(Uint8Array);
|
||||
expect(compressed.byteLength).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it('重复数据有压缩效果', () => {
|
||||
const pattern = 'ABCD';
|
||||
const repeated = pattern.repeat(100);
|
||||
const input = new TextEncoder().encode(repeated);
|
||||
const compressed = compressLZ4(input);
|
||||
expect(compressed.byteLength).toBeLessThan(input.byteLength);
|
||||
});
|
||||
|
||||
it('随机不可压缩数据不卡死', () => {
|
||||
const input = new Uint8Array(256);
|
||||
for (let i = 0; i < 256; i++) input[i] = Math.floor(Math.random() * 256);
|
||||
const compressed = compressLZ4(input);
|
||||
expect(compressed).toBeInstanceOf(Uint8Array);
|
||||
expect(compressed.byteLength).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it('长文本压缩不卡死', () => {
|
||||
const input = new TextEncoder().encode('The quick brown fox jumps over the lazy dog. '.repeat(10));
|
||||
const compressed = compressLZ4(input);
|
||||
expect(compressed).toBeTruthy();
|
||||
expect(compressed.byteLength).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it('多种长度输入均不卡死', () => {
|
||||
for (const size of [10, 50, 100, 200, 500]) {
|
||||
const input = new Uint8Array(size);
|
||||
for (let i = 0; i < size; i++) input[i] = i % 256;
|
||||
const compressed = compressLZ4(input);
|
||||
// 头部 +4 字节开销
|
||||
expect(compressed.byteLength).toBeLessThanOrEqual(input.byteLength + 4 + 16);
|
||||
}
|
||||
});
|
||||
|
||||
it('解压不抛出异常', () => {
|
||||
const input = new TextEncoder().encode('test data for decompression smoke test');
|
||||
const compressed = compressLZ4(input);
|
||||
expect(() => decompressLZ4(compressed, input.byteLength)).not.toThrow();
|
||||
});
|
||||
|
||||
// ---- v0.2.6 补强：压缩 → 解压 往返一致性 ----
|
||||
|
||||
it('往返一致：重复模式数据', () => {
|
||||
const input = new TextEncoder().encode('ABCD'.repeat(100));
|
||||
const compressed = compressLZ4(input);
|
||||
const restored = decompressLZ4(compressed, input.byteLength);
|
||||
expect(Array.from(restored)).toEqual(Array.from(input));
|
||||
});
|
||||
|
||||
it('往返一致：自然文本数据', () => {
|
||||
const input = new TextEncoder().encode(
|
||||
'The quick brown fox jumps over the lazy dog. '.repeat(10),
|
||||
);
|
||||
const compressed = compressLZ4(input);
|
||||
const restored = decompressLZ4(compressed, input.byteLength);
|
||||
expect(Array.from(restored)).toEqual(Array.from(input));
|
||||
});
|
||||
|
||||
it('往返一致：随机不可压缩数据', () => {
|
||||
const input = new Uint8Array(512);
|
||||
for (let i = 0; i < 512; i++) input[i] = Math.floor(Math.random() * 256);
|
||||
const compressed = compressLZ4(input);
|
||||
const restored = decompressLZ4(compressed, input.byteLength);
|
||||
expect(Array.from(restored)).toEqual(Array.from(input));
|
||||
});
|
||||
|
||||
it('往返一致：多种长度与字节模式', () => {
|
||||
for (const size of [4, 5, 15, 16, 17, 50, 100, 300, 1000]) {
|
||||
const input = new Uint8Array(size);
|
||||
for (let i = 0; i < size; i++) input[i] = i % 7 === 0 ? i % 256 : 0x41;
|
||||
const compressed = compressLZ4(input);
|
||||
const restored = decompressLZ4(compressed, input.byteLength);
|
||||
expect(Array.from(restored)).toEqual(Array.from(input));
|
||||
}
|
||||
});
|
||||
|
||||
it('往返一致：恰好 15 字节字面量边界', () => {
|
||||
// 字面量长度恰好 15（token 上限）时不应丢字节
|
||||
const input = new Uint8Array(15);
|
||||
for (let i = 0; i < 15; i++) input[i] = i;
|
||||
const compressed = compressLZ4(input);
|
||||
const restored = decompressLZ4(compressed, input.byteLength);
|
||||
expect(Array.from(restored)).toEqual(Array.from(input));
|
||||
});
|
||||
|
||||
it('往返一致：超过 15 字节的连续匹配', () => {
|
||||
const input = new TextEncoder().encode('X'.repeat(200) + 'Y' + 'X'.repeat(60));
|
||||
const compressed = compressLZ4(input);
|
||||
const restored = decompressLZ4(compressed, input.byteLength);
|
||||
expect(Array.from(restored)).toEqual(Array.from(input));
|
||||
});
|
||||
|
||||
it('往返一致：空输入', () => {
|
||||
const compressed = compressLZ4(new Uint8Array(0));
|
||||
expect(compressed.byteLength).toBe(4); // 仅头部
|
||||
expect(new DataView(compressed.buffer).getUint32(0, true)).toBe(0);
|
||||
const restored = decompressLZ4(compressed);
|
||||
expect(restored.byteLength).toBe(0);
|
||||
});
|
||||
|
||||
it('往返一致：头部自描述，无需外部原始大小（高压缩率回归）', () => {
|
||||
// 中文重复内容 → 极高压缩率（此前 buf.length*2 估算不足导致解压截断）
|
||||
const text = '这是需要加密的敏感内容'.repeat(500);
|
||||
const input = new TextEncoder().encode(text);
|
||||
const compressed = compressLZ4(input);
|
||||
// 压缩率验证：远小于原始
|
||||
expect(compressed.byteLength).toBeLessThan(input.byteLength / 2);
|
||||
// 不传 originalSize：从头部恢复
|
||||
const restored = decompressLZ4(compressed);
|
||||
expect(Array.from(restored)).toEqual(Array.from(input));
|
||||
});
|
||||
|
||||
it('损坏头（原始大小非法）→ 抛错而非静默截断', () => {
|
||||
const bad = new Uint8Array([0xff, 0xff, 0xff, 0xff, 0x20, 0x01, 0x02]);
|
||||
expect(() => decompressLZ4(bad)).toThrow('Invalid LZ4 header');
|
||||
});
|
||||
|
||||
it('过短输入（无头）→ 抛错', () => {
|
||||
expect(() => decompressLZ4(new Uint8Array([1, 2, 3]))).toThrow('missing header');
|
||||
});
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// MergeIterator — 归并迭代器单元测试
|
||||
// ===================================================================
|
||||
describe('AriaEngine — MergeIterator', () => {
|
||||
it('单数据源归并', () => {
|
||||
const mi = new MergeIterator();
|
||||
mi.addSource(new ArrayEntrySource([
|
||||
['a', { v: 1 }],
|
||||
['b', { v: 2 }],
|
||||
['c', { v: 3 }],
|
||||
]));
|
||||
const result = mi.drain();
|
||||
expect(result).toHaveLength(3);
|
||||
expect(result.map(([k]) => k)).toEqual(['a', 'b', 'c']);
|
||||
});
|
||||
|
||||
it('多数据源归并去重（保留最新）', () => {
|
||||
const mi = new MergeIterator();
|
||||
mi.addSource(new ArrayEntrySource([['a', { v: 'new' }], ['c', { v: 3 }]]));
|
||||
mi.addSource(new ArrayEntrySource([['a', { v: 'old' }], ['b', { v: 2 }]]));
|
||||
const result = mi.drain();
|
||||
expect(result).toHaveLength(3);
|
||||
expect(result[0][0]).toBe('a');
|
||||
expect(result[0][1].v).toBe('new');
|
||||
expect(result[1][0]).toBe('b');
|
||||
expect(result[2][0]).toBe('c');
|
||||
});
|
||||
|
||||
// ---- v0.2.6 回归：同 key 多来源时保留 sourceIndex 最小（最新）的条目 ----
|
||||
it('回归：同 key 出现在多个来源时返回 sourceIndex 最小（最新来源）的值', () => {
|
||||
const mi = new MergeIterator();
|
||||
// 语义：sourceIndex 越小越新（memtable=0 < immutable=1 < sstable=2+）
|
||||
mi.addSource(new ArrayEntrySource([['a', { v: 'source0' }]])); // 最新来源
|
||||
mi.addSource(new ArrayEntrySource([['a', { v: 'source1' }]]));
|
||||
mi.addSource(new ArrayEntrySource([['a', { v: 'source2' }]])); // 最旧来源
|
||||
const result = mi.drain();
|
||||
expect(result).toHaveLength(1);
|
||||
// 取的是 sourceIndex 最小（最新来源）的条目，而非堆序决定的任意条目
|
||||
expect(result[0][1].v).toBe('source0');
|
||||
});
|
||||
|
||||
it('回归：最新来源的值位于中间 sourceIndex 时仍取 sourceIndex 最小者', () => {
|
||||
const mi = new MergeIterator();
|
||||
mi.addSource(new ArrayEntrySource([['a', { v: 'middle' }]])); // index 0 = 最新来源
|
||||
mi.addSource(new ArrayEntrySource([['a', { v: 'newest' }]])); // index 1
|
||||
mi.addSource(new ArrayEntrySource([['a', { v: 'oldest' }]])); // index 2
|
||||
const result = mi.drain();
|
||||
expect(result).toHaveLength(1);
|
||||
expect(result[0][1].v).toBe('middle'); // index 0 的条目胜出
|
||||
});
|
||||
|
||||
it('回归：多个同 key 来源 + 其他独立 key 混合', () => {
|
||||
const mi = new MergeIterator();
|
||||
mi.addSource(new ArrayEntrySource([['a', { v: 1 }], ['b', { v: 10 }]]));
|
||||
mi.addSource(new ArrayEntrySource([['a', { v: 2 }]]));
|
||||
mi.addSource(new ArrayEntrySource([['a', { v: 3 }], ['c', { v: 30 }]]));
|
||||
const result = mi.drain();
|
||||
expect(result.map(([k]) => k)).toEqual(['a', 'b', 'c']);
|
||||
expect(result[0][1].v).toBe(1); // sourceIndex 0 = 最新
|
||||
expect(result[1][1].v).toBe(10);
|
||||
expect(result[2][1].v).toBe(30);
|
||||
});
|
||||
|
||||
it('空数据源归并', () => {
|
||||
const mi = new MergeIterator();
|
||||
mi.addSource(new ArrayEntrySource([]));
|
||||
const result = mi.drain();
|
||||
expect(result).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('大数量归并', () => {
|
||||
const mi = new MergeIterator();
|
||||
for (let s = 0; s < 5; s++) {
|
||||
const entries: [string, Record<string, unknown>][] = [];
|
||||
for (let i = 0; i < 100; i++) {
|
||||
entries.push([`src${s}-key-${String(i).padStart(3, '0')}`, { src: s, idx: i }]);
|
||||
}
|
||||
mi.addSource(new ArrayEntrySource(entries));
|
||||
}
|
||||
const result = mi.drain();
|
||||
// 5 sources × 100 unique keys = 500 total (keys are unique per source)
|
||||
expect(result).toHaveLength(500);
|
||||
});
|
||||
|
||||
it('ArrayEntrySource — 迭代器用完返回 null', () => {
|
||||
const src = new ArrayEntrySource([['k', { v: 1 }]]);
|
||||
expect(src.next()).not.toBeNull();
|
||||
expect(src.next()).toBeNull();
|
||||
expect(src.next()).toBeNull();
|
||||
});
|
||||
|
||||
it('ArrayEntrySource — reset 重置', () => {
|
||||
const src = new ArrayEntrySource([['k1', { v: 1 }], ['k2', { v: 2 }]]);
|
||||
src.next();
|
||||
src.reset();
|
||||
const val = src.next();
|
||||
expect(val![0]).toBe('k1');
|
||||
});
|
||||
});
|
||||
|
||||
@@ -5,13 +5,7 @@
|
||||
* v0.2.6 补强：此前仅验证实例化，现在验证真实的加解密往返一致性。
|
||||
*/
|
||||
import 'fake-indexeddb/auto';
|
||||
import {
|
||||
CryptoManager,
|
||||
initCrypto,
|
||||
encryptPage,
|
||||
decryptPage,
|
||||
closeCrypto,
|
||||
} from '../../src/engine/aria/crypto';
|
||||
import { CryptoManager } from '../../src/engine/aria/crypto';
|
||||
|
||||
function toBytes(data: ArrayBuffer): number[] {
|
||||
return Array.from(new Uint8Array(data));
|
||||
@@ -89,15 +83,6 @@ describe('AriaEngine — CryptoManager', () => {
|
||||
cm2.close();
|
||||
});
|
||||
|
||||
test('全局兼容层往返一致', async () => {
|
||||
await initCrypto('global-password');
|
||||
const original = new TextEncoder().encode('global compat layer').buffer;
|
||||
const { iv, data } = await encryptPage(original);
|
||||
const decrypted = await decryptPage(iv, data);
|
||||
expect(toBytes(decrypted)).toEqual(toBytes(original));
|
||||
closeCrypto();
|
||||
});
|
||||
|
||||
test('大块数据（接近页面大小）往返一致', async () => {
|
||||
const cm = new CryptoManager();
|
||||
await cm.init('page-size-test');
|
||||
@@ -111,47 +96,3 @@ describe('AriaEngine — CryptoManager', () => {
|
||||
});
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// 真实存储路径：SSTable 加密 → 持久化 → 重载解密（v0.3.2 CI 修复）
|
||||
// ===================================================================
|
||||
|
||||
describe('AriaEngine — SSTable 加密存储真实路径', () => {
|
||||
test('加密落盘后重载可完整解密', async () => {
|
||||
// eslint-disable-next-line @typescript-eslint/no-var-requires
|
||||
const { AriaEngine } = require('../../src/engine/aria/index');
|
||||
// eslint-disable-next-line @typescript-eslint/no-var-requires
|
||||
const { createSchema } = require('../../src/table/schema');
|
||||
const dbName = `enc-store-${Date.now()}`;
|
||||
|
||||
await initCrypto('engine-store-password');
|
||||
|
||||
const engine = new AriaEngine({
|
||||
storageBackend: 'indexeddb',
|
||||
walSyncMode: 'none',
|
||||
} as any);
|
||||
await engine.open(dbName, 1);
|
||||
await engine.createTable(createSchema('t', {
|
||||
id: { type: 'string', primaryKey: true },
|
||||
v: { type: 'number' },
|
||||
}));
|
||||
await engine.insert('t', [{ id: '1', v: 42 }, { id: '2', v: 99 }]);
|
||||
// 强制刷盘：SSTable 经加密保存（encryptPage 真实路径）
|
||||
await (engine as any).lsm.flush();
|
||||
await engine.close();
|
||||
|
||||
// 重载：SSTable 解密恢复
|
||||
const engine2 = new AriaEngine({
|
||||
storageBackend: 'indexeddb',
|
||||
walSyncMode: 'none',
|
||||
} as any);
|
||||
await engine2.open(dbName, 1);
|
||||
const rows = await engine2.find('t', { table: 't' });
|
||||
expect(rows).toHaveLength(2);
|
||||
const byId = Object.fromEntries(rows.map((r: any) => [r.id, r.v]));
|
||||
expect(byId['1']).toBe(42);
|
||||
expect(byId['2']).toBe(99);
|
||||
await engine2.close();
|
||||
|
||||
closeCrypto();
|
||||
});
|
||||
});
|
||||
|
||||
@@ -0,0 +1,349 @@
|
||||
/**
|
||||
* AriaEngine — 全库 AES-256-GCM 加密测试
|
||||
*
|
||||
* 覆盖：
|
||||
* 1. EncryptedBackend 单元：读写往返 / writeMany / delete / clear / 密文落盘验证
|
||||
* 2. AriaEngine 集成：密码往返（open → 写入 → close → 同密码重开数据完整）
|
||||
* 3. 错误密码 → ARIA_DECRYPT_ERROR
|
||||
* 4. 明文旧库 + 加密配置 → ARIA_ENCRYPT_CONFIG_ERROR
|
||||
* 5. 加密库 + 无密码 → ARIA_ENCRYPT_REQUIRED
|
||||
* 6. clearAll 后可换新密码重建
|
||||
* 7. 元数据（迁移版本）加密往返
|
||||
*/
|
||||
import { AriaEngine } from '../../src/engine/aria/index';
|
||||
import { EncryptedBackend } from '../../src/engine/aria/store/encrypted_backend';
|
||||
import { MemoryBackend } from '../../src/engine/aria/store/backend';
|
||||
import { createSchema } from '../../src/table/schema';
|
||||
import 'fake-indexeddb/auto';
|
||||
|
||||
let idbCounter = 0;
|
||||
function uniqueDB(): string {
|
||||
return `enc-${Date.now()}-${++idbCounter}-${Math.random().toString(36).slice(2, 8)}`;
|
||||
}
|
||||
|
||||
const SCHEMA = () => createSchema('users', {
|
||||
id: { type: 'string', primaryKey: true },
|
||||
name: { type: 'string' },
|
||||
secret: { type: 'string' },
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// EncryptedBackend 单元
|
||||
// ===================================================================
|
||||
describe('AriaEngine — EncryptedBackend 单元', () => {
|
||||
it('open 创建 keymeta，读写往返完整', async () => {
|
||||
const inner = new MemoryBackend();
|
||||
const backend = new EncryptedBackend(inner, 's3cret-password');
|
||||
await backend.open('enc-unit-1');
|
||||
|
||||
// keymeta 已创建
|
||||
const keymeta = await inner.read('__aria_keymeta');
|
||||
expect(keymeta).not.toBeNull();
|
||||
|
||||
// 读写往返
|
||||
const payload = new TextEncoder().encode('hello encrypted world').buffer;
|
||||
await backend.write('k1', payload);
|
||||
const back = await backend.read('k1');
|
||||
expect(back).not.toBeNull();
|
||||
expect(new TextDecoder().decode(back)).toBe('hello encrypted world');
|
||||
|
||||
// 底层是密文（非明文）
|
||||
const raw = await inner.read('k1');
|
||||
const rawStr = new TextDecoder().decode(raw);
|
||||
expect(rawStr).not.toContain('hello encrypted world');
|
||||
|
||||
await backend.close();
|
||||
});
|
||||
|
||||
it('writeMany / deleteMany 往返', async () => {
|
||||
const inner = new MemoryBackend();
|
||||
const backend = new EncryptedBackend(inner, 'pw');
|
||||
await backend.open('enc-unit-2');
|
||||
|
||||
const enc = (s: string) => new TextEncoder().encode(s).buffer;
|
||||
await backend.writeMany({ a: enc('AAA'), b: enc('BBB'), c: enc('CCC') });
|
||||
expect(new TextDecoder().decode(await backend.read('a'))).toBe('AAA');
|
||||
expect(new TextDecoder().decode(await backend.read('c'))).toBe('CCC');
|
||||
|
||||
await backend.deleteMany(['a', 'c']);
|
||||
expect(await backend.exists('a')).toBe(false);
|
||||
expect(await backend.exists('b')).toBe(true);
|
||||
|
||||
await backend.delete('b');
|
||||
expect(await backend.exists('b')).toBe(false);
|
||||
expect(await backend.listKeys()).toEqual(['__aria_keymeta']);
|
||||
await backend.close();
|
||||
});
|
||||
|
||||
it('每个 value 独立随机 IV（相同明文两次加密密文不同）', async () => {
|
||||
const inner = new MemoryBackend();
|
||||
const backend = new EncryptedBackend(inner, 'pw');
|
||||
await backend.open('enc-unit-3');
|
||||
|
||||
const payload = new TextEncoder().encode('same plaintext').buffer;
|
||||
await backend.write('x', payload);
|
||||
await backend.write('y', payload);
|
||||
const rawX = await inner.read('x');
|
||||
const rawY = await inner.read('y');
|
||||
// Jest toEqual 对 ArrayBuffer 不比较内容 → 字节级比较
|
||||
expect(new Uint8Array(rawX as ArrayBuffer)).not.toEqual(new Uint8Array(rawY as ArrayBuffer));
|
||||
// 但 IV 前 12 字节后的长度一致（密文长度 = 明文 + GCM tag 16B）
|
||||
expect((rawX as ArrayBuffer).byteLength).toBe((rawY as ArrayBuffer).byteLength);
|
||||
|
||||
// 但解密一致
|
||||
expect(new TextDecoder().decode(await backend.read('x'))).toBe('same plaintext');
|
||||
expect(new TextDecoder().decode(await backend.read('y'))).toBe('same plaintext');
|
||||
await backend.close();
|
||||
});
|
||||
|
||||
it('clear 清空全部数据但保留密钥元数据（库身份保留）', async () => {
|
||||
const inner = new MemoryBackend();
|
||||
const backend = new EncryptedBackend(inner, 'pw');
|
||||
await backend.open('enc-unit-4');
|
||||
await backend.write('k', new TextEncoder().encode('v').buffer);
|
||||
expect((await backend.listKeys()).length).toBe(2);
|
||||
await backend.clear();
|
||||
// 数据清空，keymeta 保留
|
||||
expect(await backend.listKeys()).toEqual(['__aria_keymeta']);
|
||||
expect(await backend.exists('k')).toBe(false);
|
||||
await backend.close();
|
||||
|
||||
// 重新打开：keymeta 仍在，同密码可用
|
||||
const backend2 = new EncryptedBackend(inner, 'pw');
|
||||
await backend2.open('enc-unit-4');
|
||||
await backend2.write('k2', new TextEncoder().encode('v2').buffer);
|
||||
expect(new TextDecoder().decode(await backend2.read('k2'))).toBe('v2');
|
||||
|
||||
// 换密码被拒（keymeta 与旧密码绑定）——注意：MemoryBackend close 清空 store，
|
||||
// 因此在 close 前验证（backend2 仍持有 inner）
|
||||
const backend3 = new EncryptedBackend(inner, 'other-pw');
|
||||
await expect(backend3.open('enc-unit-4')).rejects.toMatchObject({ code: 'ARIA_DECRYPT_ERROR' });
|
||||
await backend2.close();
|
||||
});
|
||||
|
||||
it('明文旧库（有数据无 keymeta）+ 加密 → ARIA_ENCRYPT_CONFIG_ERROR', async () => {
|
||||
const inner = new MemoryBackend();
|
||||
await inner.open('enc-unit-5');
|
||||
await inner.write('__aria_schemas', new TextEncoder().encode('{}').buffer);
|
||||
|
||||
const backend = new EncryptedBackend(inner, 'pw');
|
||||
await expect(backend.open('enc-unit-5')).rejects.toMatchObject({ code: 'ARIA_ENCRYPT_CONFIG_ERROR' });
|
||||
});
|
||||
|
||||
it('空密码配置直接抛错', () => {
|
||||
const inner = new MemoryBackend();
|
||||
try {
|
||||
new EncryptedBackend(inner, '');
|
||||
fail('should throw');
|
||||
} catch (error) {
|
||||
expect((error as { code?: string }).code).toBe('ARIA_ENCRYPT_CONFIG_ERROR');
|
||||
}
|
||||
});
|
||||
|
||||
it('getInner / isCryptoReady 访问器', async () => {
|
||||
const inner = new MemoryBackend();
|
||||
const backend = new EncryptedBackend(inner, 'pw');
|
||||
await backend.open('enc-unit-6');
|
||||
expect(backend.getInner()).toBe(inner);
|
||||
expect(backend.isCryptoReady()).toBe(true);
|
||||
await backend.close();
|
||||
expect(backend.isCryptoReady()).toBe(false);
|
||||
});
|
||||
|
||||
it('密文块被篡改 → 读取抛 ARIA_DECRYPT_ERROR（GCM 认证失败）', async () => {
|
||||
const inner = new MemoryBackend();
|
||||
const backend = new EncryptedBackend(inner, 'pw');
|
||||
await backend.open('enc-unit-7');
|
||||
await backend.write('k', new TextEncoder().encode('integrity-check').buffer);
|
||||
|
||||
// 篡改密文一个字节（绕过 IV 区）
|
||||
const raw = (await inner.read('k')) as ArrayBuffer;
|
||||
const buf = new Uint8Array(raw);
|
||||
buf[16] ^= 0xff;
|
||||
await inner.write('k', buf.buffer as ArrayBuffer);
|
||||
|
||||
await expect(backend.read('k')).rejects.toMatchObject({ code: 'ARIA_DECRYPT_ERROR' });
|
||||
await backend.close();
|
||||
});
|
||||
|
||||
it('过短密文块 → 抛 ARIA_DECRYPT_ERROR', async () => {
|
||||
const inner = new MemoryBackend();
|
||||
const backend = new EncryptedBackend(inner, 'pw');
|
||||
await backend.open('enc-unit-8');
|
||||
await inner.write('short', new Uint8Array(4).buffer); // 不足 IV(12) + tag
|
||||
await expect(backend.read('short')).rejects.toMatchObject({ code: 'ARIA_DECRYPT_ERROR' });
|
||||
await backend.close();
|
||||
});
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// AriaEngine 集成 — 加密往返
|
||||
// ===================================================================
|
||||
describe('AriaEngine — 全库加密（集成）', () => {
|
||||
it('加密库：写入 → close → 同密码重开数据完整', async () => {
|
||||
const dbName = uniqueDB();
|
||||
const engine = new AriaEngine({ storageBackend: 'indexeddb', encryption: { password: 'master-pass' } });
|
||||
await engine.open(dbName, 1);
|
||||
await engine.createTable(SCHEMA());
|
||||
await engine.insert('users', [
|
||||
{ id: '1', name: 'Alice', secret: 'top-secret-a' },
|
||||
{ id: '2', name: 'Bob', secret: 'top-secret-b' },
|
||||
]);
|
||||
await engine.setMeta('__metona_version', '3');
|
||||
await engine.close();
|
||||
|
||||
// 重开（同密码）
|
||||
const engine2 = new AriaEngine({ storageBackend: 'indexeddb', encryption: { password: 'master-pass' } });
|
||||
await engine2.open(dbName, 1);
|
||||
const rows = await engine2.find('users', { table: 'users' });
|
||||
expect(rows).toHaveLength(2);
|
||||
const byId = Object.fromEntries(rows.map((r) => [r.id, r]));
|
||||
expect(byId['1'].secret).toBe('top-secret-a');
|
||||
expect(byId['2'].secret).toBe('top-secret-b');
|
||||
expect(await engine2.getMeta('__metona_version')).toBe('3');
|
||||
await engine2.close();
|
||||
});
|
||||
|
||||
it('加密库：错误密码重开 → ARIA_DECRYPT_ERROR', async () => {
|
||||
const dbName = uniqueDB();
|
||||
const engine = new AriaEngine({ storageBackend: 'indexeddb', encryption: { password: 'right-pass' } });
|
||||
await engine.open(dbName, 1);
|
||||
await engine.createTable(SCHEMA());
|
||||
await engine.insert('users', [{ id: '1', name: 'A', secret: 'x' }]);
|
||||
await engine.close();
|
||||
|
||||
const engine2 = new AriaEngine({ storageBackend: 'indexeddb', encryption: { password: 'wrong-pass' } });
|
||||
await expect(engine2.open(dbName, 1)).rejects.toMatchObject({ code: 'ARIA_DECRYPT_ERROR' });
|
||||
});
|
||||
|
||||
it('加密库：无密码打开 → ARIA_ENCRYPT_REQUIRED', async () => {
|
||||
const dbName = uniqueDB();
|
||||
const engine = new AriaEngine({ storageBackend: 'indexeddb', encryption: { password: 'pw' } });
|
||||
await engine.open(dbName, 1);
|
||||
await engine.createTable(SCHEMA());
|
||||
await engine.close();
|
||||
|
||||
const engine2 = new AriaEngine({ storageBackend: 'indexeddb' });
|
||||
await expect(engine2.open(dbName, 1)).rejects.toMatchObject({ code: 'ARIA_ENCRYPT_REQUIRED' });
|
||||
});
|
||||
|
||||
it('明文库：加密配置打开 → ARIA_ENCRYPT_CONFIG_ERROR', async () => {
|
||||
const dbName = uniqueDB();
|
||||
const engine = new AriaEngine({ storageBackend: 'indexeddb' });
|
||||
await engine.open(dbName, 1);
|
||||
await engine.createTable(SCHEMA());
|
||||
await engine.insert('users', [{ id: '1', name: 'A', secret: 'plain' }]);
|
||||
await engine.close();
|
||||
|
||||
const engine2 = new AriaEngine({ storageBackend: 'indexeddb', encryption: { password: 'pw' } });
|
||||
await expect(engine2.open(dbName, 1)).rejects.toMatchObject({ code: 'ARIA_ENCRYPT_CONFIG_ERROR' });
|
||||
});
|
||||
|
||||
it('加密库：底层存储全部为密文（SSTable/Schema/WAL 均不可见明文）', async () => {
|
||||
const dbName = uniqueDB();
|
||||
const engine = new AriaEngine({ storageBackend: 'indexeddb', encryption: { password: 'pw' } });
|
||||
await engine.open(dbName, 1);
|
||||
await engine.createTable(SCHEMA());
|
||||
await engine.insert('users', [{ id: '1', name: 'Alice', secret: 'needle-in-cipher' }]);
|
||||
await (engine as any).lsm.flush();
|
||||
// 强制落盘后 WAL 仍有记录（checkpoint 截断前）→ 全量扫描检查
|
||||
const backend = (engine as any).backend as EncryptedBackend;
|
||||
const inner = backend.getInner();
|
||||
const keys = await inner.listKeys();
|
||||
expect(keys.length).toBeGreaterThan(0);
|
||||
|
||||
// 任何一个底层 key 的内容都不包含明文数据（需解密才可见）
|
||||
for (const key of keys) {
|
||||
if (key === '__aria_keymeta') continue;
|
||||
const raw = await inner.read(key);
|
||||
const str = new TextDecoder().decode(raw as ArrayBuffer);
|
||||
expect(str).not.toContain('needle-in-cipher');
|
||||
expect(str).not.toContain('Alice');
|
||||
expect(str).not.toContain('users');
|
||||
}
|
||||
await engine.close();
|
||||
});
|
||||
|
||||
it('加密 + 压缩组合：往返完整（压缩层先压，加密层后加密）', async () => {
|
||||
const dbName = uniqueDB();
|
||||
const engine = new AriaEngine({
|
||||
storageBackend: 'indexeddb',
|
||||
compression: true,
|
||||
encryption: { password: 'pw-compress' },
|
||||
memtableSizeThreshold: 64 * 1024 * 1024,
|
||||
});
|
||||
await engine.open(dbName, 1);
|
||||
await engine.createTable(SCHEMA());
|
||||
const rows = [] as Record<string, unknown>[];
|
||||
for (let i = 0; i < 200; i++) {
|
||||
rows.push({ id: `u-${i}`, name: `User${i}`, secret: '这是需要加密的敏感内容'.repeat(5) });
|
||||
}
|
||||
await engine.insert('users', rows);
|
||||
await (engine as any).lsm.flush();
|
||||
await engine.close();
|
||||
|
||||
const engine2 = new AriaEngine({
|
||||
storageBackend: 'indexeddb',
|
||||
compression: true,
|
||||
encryption: { password: 'pw-compress' },
|
||||
});
|
||||
await engine2.open(dbName, 1);
|
||||
expect(await engine2.count('users')).toBe(200);
|
||||
const one = await engine2.find('users', { table: 'users', where: { id: 'u-42' } });
|
||||
expect(one[0].secret).toBe('这是需要加密的敏感内容'.repeat(5));
|
||||
await engine2.close();
|
||||
});
|
||||
|
||||
it('加密库：clearAll 保留密钥（库身份），同密码重开重建，新密码被拒', async () => {
|
||||
const dbName = uniqueDB();
|
||||
const engine = new AriaEngine({ storageBackend: 'indexeddb', encryption: { password: 'old-pw' } });
|
||||
await engine.open(dbName, 1);
|
||||
await engine.createTable(SCHEMA());
|
||||
await engine.insert('users', [{ id: '1', name: 'A', secret: 'x' }]);
|
||||
await engine.clearAll();
|
||||
await engine.close();
|
||||
|
||||
// clearAll 保留 keymeta → 换新密码会被拒绝
|
||||
const engineWrong = new AriaEngine({ storageBackend: 'indexeddb', encryption: { password: 'new-pw' } });
|
||||
await expect(engineWrong.open(dbName, 1)).rejects.toMatchObject({ code: 'ARIA_DECRYPT_ERROR' });
|
||||
|
||||
// 同密码重开可重建
|
||||
const engine2 = new AriaEngine({ storageBackend: 'indexeddb', encryption: { password: 'old-pw' } });
|
||||
await engine2.open(dbName, 1);
|
||||
await engine2.createTable(SCHEMA());
|
||||
await engine2.insert('users', [{ id: '1', name: 'A', secret: 'new' }]);
|
||||
expect(await engine2.count('users')).toBe(1);
|
||||
await engine2.close();
|
||||
});
|
||||
|
||||
it('加密库：WAL 崩溃恢复路径可用（含加密 WAL）', async () => {
|
||||
const dbName = uniqueDB();
|
||||
const engine = new AriaEngine({
|
||||
storageBackend: 'indexeddb',
|
||||
encryption: { password: 'pw' },
|
||||
walSyncMode: 'full',
|
||||
checkpointInterval: 100000,
|
||||
});
|
||||
await engine.open(dbName, 1);
|
||||
await engine.createTable(SCHEMA());
|
||||
// 写入后不 flush 不 checkpoint，直接"崩溃"（close 会 checkpoint，这里模拟崩溃：直接断 backend）
|
||||
for (let i = 0; i < 10; i++) {
|
||||
await engine.insert('users', [{ id: `w-${i}`, name: `W${i}`, secret: `s${i}` }]);
|
||||
}
|
||||
// 模拟崩溃：不 close，直接断开（真实崩溃时 WAL 留在存储中）
|
||||
await (engine as any).backend.close();
|
||||
(engine as any).opened = false;
|
||||
|
||||
// 重开：WAL 重放（加密 WAL 解密后解析）
|
||||
const engine2 = new AriaEngine({
|
||||
storageBackend: 'indexeddb',
|
||||
encryption: { password: 'pw' },
|
||||
walSyncMode: 'full',
|
||||
checkpointInterval: 100000,
|
||||
});
|
||||
await engine2.open(dbName, 1);
|
||||
const rows = await engine2.find('users', { table: 'users' });
|
||||
expect(rows).toHaveLength(10);
|
||||
await engine2.close();
|
||||
});
|
||||
});
|
||||
+198
-216
@@ -1,216 +1,198 @@
|
||||
/**
|
||||
* AriaEngine Bloom Filter + MemTable 单元测试
|
||||
*/
|
||||
import { BloomFilter } from '../../src/engine/aria/index/bloom';
|
||||
import { MemTable } from '../../src/engine/aria/index/memtable';
|
||||
|
||||
// ===================================================================
|
||||
// BloomFilter
|
||||
// ===================================================================
|
||||
describe('AriaEngine — BloomFilter', () => {
|
||||
it('插入后 mayContain 返回 true', () => {
|
||||
const bf = new BloomFilter(100);
|
||||
bf.insert('hello');
|
||||
expect(bf.mayContain('hello')).toBe(true);
|
||||
});
|
||||
|
||||
it('未插入的 key mayContain 返回 false', () => {
|
||||
const bf = new BloomFilter(100);
|
||||
bf.insert('hello');
|
||||
expect(bf.mayContain('world')).toBe(false);
|
||||
});
|
||||
|
||||
it('批量插入后所有 key 都判定存在', () => {
|
||||
const bf = new BloomFilter(500);
|
||||
const keys: string[] = [];
|
||||
for (let i = 0; i < 200; i++) {
|
||||
const k = `key-${i}`;
|
||||
keys.push(k);
|
||||
bf.insert(k);
|
||||
}
|
||||
for (const k of keys) {
|
||||
expect(bf.mayContain(k)).toBe(true);
|
||||
}
|
||||
});
|
||||
|
||||
it('False positive 率可控', () => {
|
||||
const n = 500;
|
||||
const bf = new BloomFilter(n, 10);
|
||||
for (let i = 0; i < n; i++) {
|
||||
bf.insert(`present-${i}`);
|
||||
}
|
||||
let fp = 0;
|
||||
for (let i = 0; i < 500; i++) {
|
||||
if (bf.mayContain(`absent-${i}`)) fp++;
|
||||
}
|
||||
expect(fp).toBeLessThan(25);
|
||||
});
|
||||
|
||||
it('getBitSize 返回正确位数', () => {
|
||||
const bf = new BloomFilter(100, 10);
|
||||
expect(bf.getBitSize()).toBeGreaterThanOrEqual(64);
|
||||
});
|
||||
|
||||
it('getInsertedCount 追踪插入数', () => {
|
||||
const bf = new BloomFilter(100);
|
||||
bf.insert('a');
|
||||
bf.insert('b');
|
||||
bf.insert('c');
|
||||
expect(bf.getInsertedCount()).toBe(3);
|
||||
});
|
||||
|
||||
it('getHashCount 返回哈希函数数量', () => {
|
||||
const bf = new BloomFilter(1000, 10);
|
||||
expect(bf.getHashCount()).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it('serialize + fromData 往返', () => {
|
||||
const bf1 = new BloomFilter(100);
|
||||
bf1.insert('a');
|
||||
bf1.insert('b');
|
||||
const data = bf1.serialize();
|
||||
|
||||
const bf2 = BloomFilter.fromData(data, bf1.getHashCount());
|
||||
expect(bf2.mayContain('a')).toBe(true);
|
||||
expect(bf2.mayContain('b')).toBe(true);
|
||||
expect(bf2.mayContain('c')).toBe(false);
|
||||
});
|
||||
|
||||
it('空过滤器 mayContain 返回 false', () => {
|
||||
const bf = new BloomFilter(100);
|
||||
expect(bf.mayContain('anything')).toBe(false);
|
||||
});
|
||||
|
||||
it('最少 1 个哈希函数', () => {
|
||||
const bf = new BloomFilter(10, 1);
|
||||
expect(bf.getHashCount()).toBeGreaterThanOrEqual(1);
|
||||
});
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// MemTable
|
||||
// ===================================================================
|
||||
describe('AriaEngine — MemTable', () => {
|
||||
let mt: MemTable;
|
||||
|
||||
beforeEach(() => {
|
||||
mt = new MemTable(4 * 1024 * 1024);
|
||||
});
|
||||
|
||||
it('put + get 往返', () => {
|
||||
mt.put('key1', { name: 'Alice', age: 30 });
|
||||
const val = mt.get('key1');
|
||||
expect(val).not.toBeNull();
|
||||
expect(val!.name).toBe('Alice');
|
||||
});
|
||||
|
||||
it('get — 不存在的 key 返回 null', () => {
|
||||
expect(mt.get('nonexistent')).toBeNull();
|
||||
});
|
||||
|
||||
it('put 更新已存在的 key', () => {
|
||||
mt.put('k', { v: 1 });
|
||||
mt.put('k', { v: 2 });
|
||||
expect(mt.get('k')!.v).toBe(2);
|
||||
});
|
||||
|
||||
it('delete 删除成功', () => {
|
||||
mt.put('k', { v: 1 });
|
||||
expect(mt.delete('k')).toBe(true);
|
||||
expect(mt.get('k')).toBeNull();
|
||||
});
|
||||
|
||||
it('delete — 不存在的 key 返回 false', () => {
|
||||
expect(mt.delete('ghost')).toBe(false);
|
||||
});
|
||||
|
||||
it('getAllEntries 返回所有条目（有序）', () => {
|
||||
mt.put('c', { v: 3 });
|
||||
mt.put('a', { v: 1 });
|
||||
mt.put('b', { v: 2 });
|
||||
const entries = mt.getAllEntries();
|
||||
expect(entries).toHaveLength(3);
|
||||
expect(entries[0][0]).toBe('a');
|
||||
expect(entries[1][0]).toBe('b');
|
||||
expect(entries[2][0]).toBe('c');
|
||||
});
|
||||
|
||||
it('rangeScan — 范围查询', () => {
|
||||
mt.put('a', { v: 1 });
|
||||
mt.put('b', { v: 2 });
|
||||
mt.put('c', { v: 3 });
|
||||
mt.put('d', { v: 4 });
|
||||
const results = mt.rangeScan('b', 'c');
|
||||
expect(results).toHaveLength(2);
|
||||
expect(results[0][0]).toBe('b');
|
||||
expect(results[1][0]).toBe('c');
|
||||
});
|
||||
|
||||
it('rangeScan — 空结果', () => {
|
||||
mt.put('a', { v: 1 });
|
||||
const results = mt.rangeScan('z', 'zz');
|
||||
expect(results).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('getEntryCount 正确计数', () => {
|
||||
expect(mt.getEntryCount()).toBe(0);
|
||||
mt.put('a', { v: 1 });
|
||||
mt.put('b', { v: 2 });
|
||||
expect(mt.getEntryCount()).toBe(2);
|
||||
mt.delete('a');
|
||||
expect(mt.getEntryCount()).toBe(1);
|
||||
});
|
||||
|
||||
it('contains 检查存在性', () => {
|
||||
mt.put('x', { v: 1 });
|
||||
expect(mt.contains('x')).toBe(true);
|
||||
expect(mt.contains('y')).toBe(false);
|
||||
});
|
||||
|
||||
it('shouldFlush — 未达阈值返回 false', () => {
|
||||
expect(mt.shouldFlush()).toBe(false);
|
||||
});
|
||||
|
||||
it('clear 清空所有数据', () => {
|
||||
mt.put('a', { v: 1 });
|
||||
mt.put('b', { v: 2 });
|
||||
mt.clear();
|
||||
expect(mt.getEntryCount()).toBe(0);
|
||||
expect(mt.get('a')).toBeNull();
|
||||
});
|
||||
|
||||
it('getEstimatedSize 返回合理估计值', () => {
|
||||
expect(mt.getEstimatedSize()).toBe(0);
|
||||
mt.put('hello', { name: 'world', count: 42 });
|
||||
expect(mt.getEstimatedSize()).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it('大量数据插入保持有序', () => {
|
||||
const count = 100;
|
||||
for (let i = count - 1; i >= 0; i--) {
|
||||
mt.put(`key-${String(i).padStart(3, '0')}`, { idx: i });
|
||||
}
|
||||
const entries = mt.getAllEntries();
|
||||
expect(entries).toHaveLength(count);
|
||||
for (let i = 0; i < count; i++) {
|
||||
expect(entries[i][1].idx).toBe(i);
|
||||
}
|
||||
});
|
||||
|
||||
it('删除后重新插入', () => {
|
||||
mt.put('k', { v: 1 });
|
||||
mt.delete('k');
|
||||
mt.put('k', { v: 2 });
|
||||
expect(mt.get('k')!.v).toBe(2);
|
||||
});
|
||||
|
||||
it('范围扫描包含边界', () => {
|
||||
mt.put('aa', { v: 1 });
|
||||
mt.put('ab', { v: 2 });
|
||||
mt.put('ac', { v: 3 });
|
||||
const results = mt.rangeScan('aa', 'ab');
|
||||
expect(results).toHaveLength(2);
|
||||
expect(results[0][0]).toBe('aa');
|
||||
expect(results[1][0]).toBe('ab');
|
||||
});
|
||||
});
|
||||
/**
|
||||
* AriaEngine Bloom Filter + MemTable 单元测试
|
||||
*/
|
||||
import { BloomFilter } from '../../src/engine/aria/index/bloom';
|
||||
import { MemTable } from '../../src/engine/aria/index/memtable';
|
||||
|
||||
// ===================================================================
|
||||
// BloomFilter
|
||||
// ===================================================================
|
||||
describe('AriaEngine — BloomFilter', () => {
|
||||
it('插入后 mayContain 返回 true', () => {
|
||||
const bf = new BloomFilter(100);
|
||||
bf.insert('hello');
|
||||
expect(bf.mayContain('hello')).toBe(true);
|
||||
});
|
||||
|
||||
it('未插入的 key mayContain 返回 false', () => {
|
||||
const bf = new BloomFilter(100);
|
||||
bf.insert('hello');
|
||||
expect(bf.mayContain('world')).toBe(false);
|
||||
});
|
||||
|
||||
it('批量插入后所有 key 都判定存在', () => {
|
||||
const bf = new BloomFilter(500);
|
||||
const keys: string[] = [];
|
||||
for (let i = 0; i < 200; i++) {
|
||||
const k = `key-${i}`;
|
||||
keys.push(k);
|
||||
bf.insert(k);
|
||||
}
|
||||
for (const k of keys) {
|
||||
expect(bf.mayContain(k)).toBe(true);
|
||||
}
|
||||
});
|
||||
|
||||
it('False positive 率可控', () => {
|
||||
const n = 500;
|
||||
const bf = new BloomFilter(n, 10);
|
||||
for (let i = 0; i < n; i++) {
|
||||
bf.insert(`present-${i}`);
|
||||
}
|
||||
let fp = 0;
|
||||
for (let i = 0; i < 500; i++) {
|
||||
if (bf.mayContain(`absent-${i}`)) fp++;
|
||||
}
|
||||
expect(fp).toBeLessThan(25);
|
||||
});
|
||||
|
||||
it('getHashCount 返回哈希函数数量', () => {
|
||||
const bf = new BloomFilter(1000, 10);
|
||||
expect(bf.getHashCount()).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it('serialize + fromData 往返', () => {
|
||||
const bf1 = new BloomFilter(100);
|
||||
bf1.insert('a');
|
||||
bf1.insert('b');
|
||||
const data = bf1.serialize();
|
||||
|
||||
const bf2 = BloomFilter.fromData(data, bf1.getHashCount());
|
||||
expect(bf2.mayContain('a')).toBe(true);
|
||||
expect(bf2.mayContain('b')).toBe(true);
|
||||
expect(bf2.mayContain('c')).toBe(false);
|
||||
});
|
||||
|
||||
it('空过滤器 mayContain 返回 false', () => {
|
||||
const bf = new BloomFilter(100);
|
||||
expect(bf.mayContain('anything')).toBe(false);
|
||||
});
|
||||
|
||||
it('最少 1 个哈希函数', () => {
|
||||
const bf = new BloomFilter(10, 1);
|
||||
expect(bf.getHashCount()).toBeGreaterThanOrEqual(1);
|
||||
});
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// MemTable
|
||||
// ===================================================================
|
||||
describe('AriaEngine — MemTable', () => {
|
||||
let mt: MemTable;
|
||||
|
||||
beforeEach(() => {
|
||||
mt = new MemTable(4 * 1024 * 1024);
|
||||
});
|
||||
|
||||
it('put + get 往返', () => {
|
||||
mt.put('key1', { name: 'Alice', age: 30 });
|
||||
const val = mt.get('key1');
|
||||
expect(val).not.toBeNull();
|
||||
expect(val!.name).toBe('Alice');
|
||||
});
|
||||
|
||||
it('get — 不存在的 key 返回 null', () => {
|
||||
expect(mt.get('nonexistent')).toBeNull();
|
||||
});
|
||||
|
||||
it('put 更新已存在的 key', () => {
|
||||
mt.put('k', { v: 1 });
|
||||
mt.put('k', { v: 2 });
|
||||
expect(mt.get('k')!.v).toBe(2);
|
||||
});
|
||||
|
||||
it('delete 删除成功', () => {
|
||||
mt.put('k', { v: 1 });
|
||||
expect(mt.delete('k')).toBe(true);
|
||||
expect(mt.get('k')).toBeNull();
|
||||
});
|
||||
|
||||
it('delete — 不存在的 key 返回 false', () => {
|
||||
expect(mt.delete('ghost')).toBe(false);
|
||||
});
|
||||
|
||||
it('getAllEntries 返回所有条目（有序）', () => {
|
||||
mt.put('c', { v: 3 });
|
||||
mt.put('a', { v: 1 });
|
||||
mt.put('b', { v: 2 });
|
||||
const entries = mt.getAllEntries();
|
||||
expect(entries).toHaveLength(3);
|
||||
expect(entries[0][0]).toBe('a');
|
||||
expect(entries[1][0]).toBe('b');
|
||||
expect(entries[2][0]).toBe('c');
|
||||
});
|
||||
|
||||
it('rangeScan — 范围查询', () => {
|
||||
mt.put('a', { v: 1 });
|
||||
mt.put('b', { v: 2 });
|
||||
mt.put('c', { v: 3 });
|
||||
mt.put('d', { v: 4 });
|
||||
const results = mt.rangeScan('b', 'c');
|
||||
expect(results).toHaveLength(2);
|
||||
expect(results[0][0]).toBe('b');
|
||||
expect(results[1][0]).toBe('c');
|
||||
});
|
||||
|
||||
it('rangeScan — 空结果', () => {
|
||||
mt.put('a', { v: 1 });
|
||||
const results = mt.rangeScan('z', 'zz');
|
||||
expect(results).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('getEntryCount 正确计数', () => {
|
||||
expect(mt.getEntryCount()).toBe(0);
|
||||
mt.put('a', { v: 1 });
|
||||
mt.put('b', { v: 2 });
|
||||
expect(mt.getEntryCount()).toBe(2);
|
||||
mt.delete('a');
|
||||
expect(mt.getEntryCount()).toBe(1);
|
||||
});
|
||||
|
||||
|
||||
it('shouldFlush — 未达阈值返回 false', () => {
|
||||
expect(mt.shouldFlush()).toBe(false);
|
||||
});
|
||||
|
||||
it('clear 清空所有数据', () => {
|
||||
mt.put('a', { v: 1 });
|
||||
mt.put('b', { v: 2 });
|
||||
mt.clear();
|
||||
expect(mt.getEntryCount()).toBe(0);
|
||||
expect(mt.get('a')).toBeNull();
|
||||
});
|
||||
|
||||
it('getEstimatedSize 返回合理估计值', () => {
|
||||
expect(mt.getEstimatedSize()).toBe(0);
|
||||
mt.put('hello', { name: 'world', count: 42 });
|
||||
expect(mt.getEstimatedSize()).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it('大量数据插入保持有序', () => {
|
||||
const count = 100;
|
||||
for (let i = count - 1; i >= 0; i--) {
|
||||
mt.put(`key-${String(i).padStart(3, '0')}`, { idx: i });
|
||||
}
|
||||
const entries = mt.getAllEntries();
|
||||
expect(entries).toHaveLength(count);
|
||||
for (let i = 0; i < count; i++) {
|
||||
expect(entries[i][1].idx).toBe(i);
|
||||
}
|
||||
});
|
||||
|
||||
it('删除后重新插入', () => {
|
||||
mt.put('k', { v: 1 });
|
||||
mt.delete('k');
|
||||
mt.put('k', { v: 2 });
|
||||
expect(mt.get('k')!.v).toBe(2);
|
||||
});
|
||||
|
||||
it('范围扫描包含边界', () => {
|
||||
mt.put('aa', { v: 1 });
|
||||
mt.put('ab', { v: 2 });
|
||||
mt.put('ac', { v: 3 });
|
||||
const results = mt.rangeScan('aa', 'ab');
|
||||
expect(results).toHaveLength(2);
|
||||
expect(results[0][0]).toBe('aa');
|
||||
expect(results[1][0]).toBe('ab');
|
||||
});
|
||||
});
|
||||
|
||||
@@ -0,0 +1,170 @@
|
||||
/**
|
||||
* AriaEngine — 多标签页独占锁（Web Locks）测试
|
||||
*
|
||||
* 覆盖：
|
||||
* 1. 第一个引擎持锁 → 第二个引擎打开抛 ARIA_LOCKED
|
||||
* 2. 关闭后锁释放 → 可再次打开
|
||||
* 3. 环境不支持 Web Locks → 降级打开（返回 false 语义 + 警告）
|
||||
* 4. open 失败（如加密密码错误）→ 锁释放（其他标签页可打开）
|
||||
* 5. 锁名按库隔离（不同库不互斥）
|
||||
*/
|
||||
import { AriaEngine } from '../../src/engine/aria/index';
|
||||
import { DatabaseLock, lockName } from '../../src/engine/aria/locks';
|
||||
import { createSchema } from '../../src/table/schema';
|
||||
import 'fake-indexeddb/auto';
|
||||
|
||||
let idbCounter = 0;
|
||||
function uniqueDB(): string {
|
||||
return `lock-${Date.now()}-${++idbCounter}-${Math.random().toString(36).slice(2, 8)}`;
|
||||
}
|
||||
|
||||
// ===================================================================
|
||||
// Web Locks mock：真实语义（ifAvailable / 回调结束锁自动释放）
|
||||
// ===================================================================
|
||||
let lockHolders: Map<string, true>;
|
||||
|
||||
function installLocksMock() {
|
||||
lockHolders = new Map();
|
||||
Object.defineProperty(globalThis, 'navigator', {
|
||||
value: {
|
||||
locks: {
|
||||
request: async (_name: string, opts: { ifAvailable?: boolean }, cb: (lock: { name: string } | null) => Promise<void> | void) => {
|
||||
const name = _name;
|
||||
if (lockHolders.has(name)) {
|
||||
if (opts?.ifAvailable) {
|
||||
await cb(null);
|
||||
return;
|
||||
}
|
||||
throw new Error('unreachable: non-ifAvailable request not used');
|
||||
}
|
||||
lockHolders.set(name, true);
|
||||
try {
|
||||
// 真实 Web Locks 语义：回调结束 → 锁自动释放
|
||||
await cb({ name });
|
||||
} finally {
|
||||
lockHolders.delete(name);
|
||||
}
|
||||
},
|
||||
},
|
||||
},
|
||||
configurable: true,
|
||||
writable: true,
|
||||
});
|
||||
}
|
||||
|
||||
function removeLocksMock() {
|
||||
Object.defineProperty(globalThis, 'navigator', {
|
||||
value: {},
|
||||
configurable: true,
|
||||
writable: true,
|
||||
});
|
||||
}
|
||||
|
||||
// ===================================================================
|
||||
// DatabaseLock 单元
|
||||
// ===================================================================
|
||||
describe('AriaEngine — DatabaseLock 单元', () => {
|
||||
beforeEach(installLocksMock);
|
||||
|
||||
it('acquire 持锁 → 二次 acquire 抛 ARIA_LOCKED → release 后恢复', async () => {
|
||||
const lock1 = new DatabaseLock();
|
||||
expect(await lock1.acquire('db-a')).toBe(true);
|
||||
expect(lock1.isAcquired()).toBe(true);
|
||||
expect(lock1.isSupported()).toBe(true);
|
||||
expect(lockHolders.has(lockName('db-a'))).toBe(true);
|
||||
|
||||
const lock2 = new DatabaseLock();
|
||||
await expect(lock2.acquire('db-a')).rejects.toMatchObject({ code: 'ARIA_LOCKED' });
|
||||
expect(lock2.isAcquired()).toBe(false);
|
||||
|
||||
await lock1.release();
|
||||
expect(lock1.isAcquired()).toBe(false);
|
||||
expect(lockHolders.has(lockName('db-a'))).toBe(false);
|
||||
|
||||
const lock3 = new DatabaseLock();
|
||||
expect(await lock3.acquire('db-a')).toBe(true);
|
||||
await lock3.release();
|
||||
});
|
||||
|
||||
it('不同库名互不阻塞', async () => {
|
||||
const l1 = new DatabaseLock();
|
||||
const l2 = new DatabaseLock();
|
||||
expect(await l1.acquire('db-x')).toBe(true);
|
||||
expect(await l2.acquire('db-y')).toBe(true);
|
||||
await l1.release();
|
||||
await l2.release();
|
||||
});
|
||||
|
||||
it('无 Web Locks 环境 → acquire 返回 false（降级）', async () => {
|
||||
removeLocksMock();
|
||||
const lock = new DatabaseLock();
|
||||
expect(await lock.acquire('db-z')).toBe(false);
|
||||
expect(lock.isSupported()).toBe(false);
|
||||
expect(lock.isAcquired()).toBe(false);
|
||||
});
|
||||
|
||||
it('重复 release 幂等', async () => {
|
||||
const lock = new DatabaseLock();
|
||||
await lock.acquire('db-r');
|
||||
await lock.release();
|
||||
await lock.release();
|
||||
expect(lock.isAcquired()).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// AriaEngine 集成 — 多标签页锁
|
||||
// ===================================================================
|
||||
describe('AriaEngine — 多标签页锁（集成）', () => {
|
||||
beforeEach(installLocksMock);
|
||||
|
||||
it('第二个标签页打开同一库 → ARIA_LOCKED', async () => {
|
||||
const dbName = uniqueDB();
|
||||
const engine1 = new AriaEngine({ storageBackend: 'indexeddb' });
|
||||
await engine1.open(dbName, 1);
|
||||
await engine1.createTable(createSchema('t', { id: { type: 'string', primaryKey: true } }));
|
||||
|
||||
const engine2 = new AriaEngine({ storageBackend: 'indexeddb' });
|
||||
await expect(engine2.open(dbName, 1)).rejects.toMatchObject({ code: 'ARIA_LOCKED' });
|
||||
// engine2 未持锁、未 opened
|
||||
expect((engine2 as any).opened).toBe(false);
|
||||
|
||||
await engine1.close();
|
||||
|
||||
// 释放后可打开
|
||||
const engine3 = new AriaEngine({ storageBackend: 'indexeddb' });
|
||||
await engine3.open(dbName, 1);
|
||||
expect(await engine3.count('t')).toBe(0);
|
||||
await engine3.close();
|
||||
});
|
||||
|
||||
it('open 失败（错误密码）→ 锁释放，其他标签页可打开', async () => {
|
||||
const dbName = uniqueDB();
|
||||
const engine1 = new AriaEngine({ storageBackend: 'indexeddb', encryption: { password: 'pw' } });
|
||||
await engine1.open(dbName, 1);
|
||||
await engine1.createTable(createSchema('t', { id: { type: 'string', primaryKey: true } }));
|
||||
await engine1.close();
|
||||
|
||||
// 错误密码 → open 失败
|
||||
const engineBad = new AriaEngine({ storageBackend: 'indexeddb', encryption: { password: 'wrong' } });
|
||||
await expect(engineBad.open(dbName, 1)).rejects.toMatchObject({ code: 'ARIA_DECRYPT_ERROR' });
|
||||
// 失败后锁已释放（未泄漏）
|
||||
expect(lockHolders.has(lockName(dbName))).toBe(false);
|
||||
|
||||
// 正确密码可打开
|
||||
const engineOk = new AriaEngine({ storageBackend: 'indexeddb', encryption: { password: 'pw' } });
|
||||
await engineOk.open(dbName, 1);
|
||||
await engineOk.close();
|
||||
});
|
||||
|
||||
it('无 Web Locks 环境 → 降级打开（不抛错）', async () => {
|
||||
removeLocksMock();
|
||||
const dbName = uniqueDB();
|
||||
const engine = new AriaEngine({ storageBackend: 'indexeddb' });
|
||||
await engine.open(dbName, 1);
|
||||
await engine.createTable(createSchema('t', { id: { type: 'string', primaryKey: true } }));
|
||||
await engine.insert('t', [{ id: '1' }]);
|
||||
expect(await engine.count('t')).toBe(1);
|
||||
await engine.close();
|
||||
});
|
||||
});
|
||||
@@ -81,23 +81,6 @@ describe('AriaEngine — ANALYZE/VACUUM/REINDEX + EXPLAIN', () => {
|
||||
expect(plan.actualTimeMs).toBeGreaterThanOrEqual(0);
|
||||
});
|
||||
|
||||
// ---- 查询优化器 ----
|
||||
it('estimateQueryCost PK 等值 → pk_lookup', () => {
|
||||
const cost = (engine as any).estimateQueryCost('users', { table: 'users', where: { id: '1' } });
|
||||
expect(cost.strategy).toBe('pk_lookup');
|
||||
expect(cost.estimatedRows).toBe(1);
|
||||
});
|
||||
|
||||
it('estimateQueryCost 索引等值 → index_eq', () => {
|
||||
const cost = (engine as any).estimateQueryCost('users', { table: 'users', where: { name: 'Alice' } });
|
||||
expect(cost.strategy).toBe('index_eq:name');
|
||||
});
|
||||
|
||||
it('estimateQueryCost 无索引 → full_scan', () => {
|
||||
const cost = (engine as any).estimateQueryCost('users', { table: 'users', where: { age: { $gt: 20 } } });
|
||||
expect(cost.strategy).toMatch(/index_range|full_scan/);
|
||||
});
|
||||
|
||||
// ---- 在线备份 ----
|
||||
it('backup 导出全库一致性快照', async () => {
|
||||
const backup = await (engine as any).backup();
|
||||
|
||||
@@ -27,31 +27,20 @@ describe('AriaEngine — MVCC 事务 + Savepoint', () => {
|
||||
expect(id1).not.toBe(id2);
|
||||
});
|
||||
|
||||
it('commit 后事务标记为非活跃', () => {
|
||||
it('commit 后版本标记已提交', () => {
|
||||
const txnId = (engine as any).mvcc.beginTransaction();
|
||||
(engine as any).mvcc.writeVersion('users', '1', { name: 'Alice' }, txnId);
|
||||
(engine as any).mvcc.commitTransaction(txnId);
|
||||
expect((engine as any).mvcc.isActive(txnId)).toBe(false);
|
||||
const store = (engine as any).mvcc.versionStore;
|
||||
expect(store.get('users.1')[0].committed).toBe(true);
|
||||
});
|
||||
|
||||
it('rollback 后事务标记为非活跃', () => {
|
||||
it('rollback 移除本事务版本', () => {
|
||||
const txnId = (engine as any).mvcc.beginTransaction();
|
||||
(engine as any).mvcc.writeVersion('users', '1', { name: 'Alice' }, txnId);
|
||||
(engine as any).mvcc.rollbackTransaction(txnId);
|
||||
expect((engine as any).mvcc.isActive(txnId)).toBe(false);
|
||||
});
|
||||
|
||||
it('事务中写入版本可读', () => {
|
||||
const txnId = (engine as any).mvcc.beginTransaction();
|
||||
(engine as any).mvcc.writeVersion('users', '1', { name: 'Alice', balance: 100 }, txnId);
|
||||
const val = (engine as any).mvcc.readVersion('users', '1', txnId);
|
||||
expect(val).not.toBeNull();
|
||||
expect(val!.name).toBe('Alice');
|
||||
});
|
||||
|
||||
it('未提交版本对其他事务不可见', () => {
|
||||
const txn1 = (engine as any).mvcc.beginTransaction();
|
||||
(engine as any).mvcc.writeVersion('users', '1', { name: 'Alice' }, txn1);
|
||||
const txn2 = (engine as any).mvcc.beginTransaction();
|
||||
expect((engine as any).mvcc.readVersion('users', '1', txn2)).toBeNull();
|
||||
const store = (engine as any).mvcc.versionStore;
|
||||
expect(store.has('users.1')).toBe(false);
|
||||
});
|
||||
|
||||
it('引擎层事务 commit 后数据可见', async () => {
|
||||
@@ -69,16 +58,14 @@ describe('AriaEngine — MVCC 事务 + Savepoint', () => {
|
||||
expect(await engine.count('users')).toBe(1);
|
||||
});
|
||||
|
||||
it('GC 清理过旧版本', () => {
|
||||
it('GC 清理过旧版本（保留最新 N 个）', () => {
|
||||
for (let i = 0; i < 200; i++) {
|
||||
const txnId = (engine as any).mvcc.beginTransaction();
|
||||
(engine as any).mvcc.writeVersion('users', '1', { ver: i }, txnId);
|
||||
(engine as any).mvcc.commitTransaction(txnId);
|
||||
}
|
||||
(engine as any).mvcc.gc(50);
|
||||
const txnId = (engine as any).mvcc.beginTransaction();
|
||||
expect((engine as any).mvcc.readVersion('users', '1', txnId)).not.toBeNull();
|
||||
(engine as any).mvcc.commitTransaction(txnId);
|
||||
expect((engine as any).mvcc.versionStore.get('users.1').length).toBe(50);
|
||||
});
|
||||
|
||||
// ---- Savepoint ----
|
||||
|
||||
@@ -0,0 +1,228 @@
|
||||
/**
|
||||
* AriaEngine — OPFSBackend v2 测试
|
||||
*
|
||||
* 覆盖：
|
||||
* 1. read/write/append/exists/delete/clear 基本语义
|
||||
* 2. append 追加语义（keepExistingData + position）与字节顺序
|
||||
* 3. 写队列串行化（并发写顺序一致）
|
||||
* 4. 单次任务失败不中断队列链（后续写正常）
|
||||
* 5. close 等待挂起写完成
|
||||
* 6. open 清理崩溃残留临时文件（.crswap/.tmp）
|
||||
* 7. writeMany/deleteMany 语义
|
||||
*/
|
||||
import { OPFSBackend } from '../../src/engine/aria/store/opfs_backend';
|
||||
|
||||
// ===================================================================
|
||||
// 真实语义 OPFS mock：记录文件内容、支持 keepExistingData+position
|
||||
// ===================================================================
|
||||
interface MockFile {
|
||||
content: ArrayBuffer;
|
||||
writeCalls: { position?: number; data: ArrayBuffer; keepExistingData?: boolean }[];
|
||||
}
|
||||
|
||||
function createOPFSMock() {
|
||||
const files = new Map<string, MockFile>();
|
||||
|
||||
const getFileHandle = async (name: string, opts?: { create?: boolean }) => {
|
||||
if (!files.has(name)) {
|
||||
if (!opts?.create) throw new Error(`NotFoundError: ${name}`);
|
||||
files.set(name, { content: new ArrayBuffer(0), writeCalls: [] });
|
||||
}
|
||||
const entry = files.get(name)!;
|
||||
return {
|
||||
getFile: async () => ({ size: entry.content.byteLength, arrayBuffer: async () => entry.content }),
|
||||
createWritable: async (wOpts?: { keepExistingData?: boolean }) => {
|
||||
const w: {
|
||||
write: (arg: ArrayBuffer | { type: string; position: number; data: ArrayBuffer }) => Promise<void>;
|
||||
close: () => Promise<void>;
|
||||
} = {
|
||||
write: async (arg) => {
|
||||
const keepExisting = wOpts?.keepExistingData ?? false;
|
||||
const isChunk = typeof arg !== 'object' || !('type' in (arg as object)) || (arg as { type?: string }).type === undefined
|
||||
? { data: arg as ArrayBuffer, position: keepExisting ? entry.content.byteLength : 0 }
|
||||
: { data: (arg as { data: ArrayBuffer }).data, position: (arg as { position: number }).position };
|
||||
entry.writeCalls.push({ position: isChunk.position, data: isChunk.data, keepExistingData: keepExisting });
|
||||
const merged = new Uint8Array(isChunk.position + isChunk.data.byteLength);
|
||||
if (keepExisting || isChunk.position > 0) {
|
||||
merged.set(new Uint8Array(entry.content.subarray ? entry.content : entry.content), 0);
|
||||
}
|
||||
merged.set(new Uint8Array(isChunk.data), isChunk.position);
|
||||
entry.content = merged.buffer;
|
||||
},
|
||||
close: async () => { /* no-op */ },
|
||||
};
|
||||
return w;
|
||||
},
|
||||
};
|
||||
};
|
||||
|
||||
const dir = {
|
||||
getFileHandle,
|
||||
entries: async function* () {
|
||||
for (const [name] of files) yield [name];
|
||||
},
|
||||
removeEntry: async (name: string) => {
|
||||
files.delete(name);
|
||||
},
|
||||
};
|
||||
|
||||
Object.defineProperty(globalThis, 'navigator', {
|
||||
value: {
|
||||
storage: {
|
||||
getDirectory: async () => ({
|
||||
getDirectoryHandle: async (_name: string, _opts?: unknown) => dir,
|
||||
}),
|
||||
},
|
||||
},
|
||||
configurable: true,
|
||||
writable: true,
|
||||
});
|
||||
|
||||
return { files, dir };
|
||||
}
|
||||
|
||||
const enc = (s: string) => new Uint8Array(new TextEncoder().encode(s)).buffer;
|
||||
|
||||
describe('AriaEngine — OPFSBackend v2', () => {
|
||||
beforeEach(() => {
|
||||
createOPFSMock();
|
||||
});
|
||||
|
||||
it('read/write/exists/delete 基本语义', async () => {
|
||||
const backend = new OPFSBackend();
|
||||
await backend.open('opfs-test-1');
|
||||
expect(backend.isOpen()).toBe(true);
|
||||
|
||||
await backend.write('k1', enc('hello'));
|
||||
expect(await backend.exists('k1')).toBe(true);
|
||||
expect(new TextDecoder().decode(await backend.read('k1'))).toBe('hello');
|
||||
expect(await backend.read('missing')).toBeNull();
|
||||
|
||||
await backend.delete('k1');
|
||||
expect(await backend.exists('k1')).toBe(false);
|
||||
await backend.close();
|
||||
expect(backend.isOpen()).toBe(false);
|
||||
});
|
||||
|
||||
it('append 追加语义：字节顺序与位置正确', async () => {
|
||||
const backend = new OPFSBackend();
|
||||
await backend.open('opfs-test-2');
|
||||
await backend.append('wal', enc('AAA'));
|
||||
await backend.append('wal', enc('BBB'));
|
||||
await backend.append('wal', enc('CCC'));
|
||||
const all = await backend.read('wal');
|
||||
expect(new TextDecoder().decode(all)).toBe('AAABBBCCC');
|
||||
await backend.close();
|
||||
});
|
||||
|
||||
it('write 覆盖语义（COW 原子替换）', async () => {
|
||||
const backend = new OPFSBackend();
|
||||
await backend.open('opfs-test-3');
|
||||
await backend.write('f', enc('OLD-CONTENT'));
|
||||
await backend.write('f', enc('NEW'));
|
||||
expect(new TextDecoder().decode(await backend.read('f'))).toBe('NEW');
|
||||
await backend.close();
|
||||
});
|
||||
|
||||
it('并发写串行化：写入顺序与调用顺序一致', async () => {
|
||||
const backend = new OPFSBackend();
|
||||
await backend.open('opfs-test-4');
|
||||
// 同时发起多个写（不 await 中间结果）
|
||||
const p1 = backend.append('log', enc('A'));
|
||||
const p2 = backend.append('log', enc('B'));
|
||||
const p3 = backend.append('log', enc('C'));
|
||||
await Promise.all([p1, p2, p3]);
|
||||
expect(new TextDecoder().decode(await backend.read('log'))).toBe('ABC');
|
||||
await backend.close();
|
||||
});
|
||||
|
||||
it('单次写失败不中断队列链，后续写正常', async () => {
|
||||
const backend = new OPFSBackend();
|
||||
await backend.open('opfs-test-5');
|
||||
|
||||
// 注入失败：让 write 抛错一次
|
||||
let failNext = true;
|
||||
const origWrite = backend.write.bind(backend);
|
||||
const mockDir = (backend as any).dbDir;
|
||||
const origGetFileHandle = mockDir.getFileHandle.bind(mockDir);
|
||||
mockDir.getFileHandle = async (name: string, opts?: { create?: boolean }) => {
|
||||
if (failNext && name === 'boom') {
|
||||
failNext = false;
|
||||
throw new Error('Injected write failure');
|
||||
}
|
||||
return origGetFileHandle(name, opts);
|
||||
};
|
||||
(backend as any).dbDir = mockDir;
|
||||
|
||||
await expect(origWrite('boom', enc('x'))).rejects.toThrow('Injected write failure');
|
||||
// 队列链恢复：后续写成功
|
||||
await backend.write('ok', enc('fine'));
|
||||
expect(new TextDecoder().decode(await backend.read('ok'))).toBe('fine');
|
||||
await backend.close();
|
||||
});
|
||||
|
||||
it('close 等待挂起写完成（挂起写不丢失）', async () => {
|
||||
const backend = new OPFSBackend();
|
||||
await backend.open('opfs-test-6');
|
||||
|
||||
// 发起一个写但不 await，立即 close
|
||||
const pending = backend.append('late', enc('LATE-DATA'));
|
||||
await backend.close();
|
||||
await pending; // close 已等队列 → 写已完成
|
||||
expect(pending).resolves.toBeUndefined();
|
||||
});
|
||||
|
||||
it('open 清理崩溃残留临时文件（.crswap/.tmp）', async () => {
|
||||
const backend = new OPFSBackend();
|
||||
await backend.open('opfs-test-7');
|
||||
await backend.write('data', enc('real'));
|
||||
// 手工制造残留
|
||||
const mockDir = (backend as any).dbDir;
|
||||
await mockDir.getFileHandle('data.crswap', { create: true });
|
||||
await mockDir.getFileHandle('data.tmp', { create: true });
|
||||
await backend.close();
|
||||
|
||||
// 重开：open 自动清理
|
||||
const backend2 = new OPFSBackend();
|
||||
await backend2.open('opfs-test-7');
|
||||
const keys = await backend2.listKeys();
|
||||
expect(keys).toEqual(['data']);
|
||||
expect(keys.some((k) => k.endsWith('.crswap') || k.endsWith('.tmp'))).toBe(false);
|
||||
// 正常数据不受影响
|
||||
expect(new TextDecoder().decode(await backend2.read('data'))).toBe('real');
|
||||
await backend2.close();
|
||||
});
|
||||
|
||||
it('writeMany / deleteMany 语义', async () => {
|
||||
const backend = new OPFSBackend();
|
||||
await backend.open('opfs-test-8');
|
||||
await backend.writeMany({ a: enc('AAA'), b: enc('BBB') });
|
||||
expect(new TextDecoder().decode(await backend.read('a'))).toBe('AAA');
|
||||
expect(new TextDecoder().decode(await backend.read('b'))).toBe('BBB');
|
||||
await backend.deleteMany(['a']);
|
||||
expect(await backend.exists('a')).toBe(false);
|
||||
expect(await backend.exists('b')).toBe(true);
|
||||
await backend.clear();
|
||||
expect(await backend.listKeys()).toEqual([]);
|
||||
await backend.close();
|
||||
});
|
||||
|
||||
it('close 后所有操作安全返回（dbDir 为 null 不抛错）', async () => {
|
||||
const backend = new OPFSBackend();
|
||||
await backend.open('opfs-test-9');
|
||||
await backend.write('k', enc('v'));
|
||||
await backend.close();
|
||||
|
||||
expect(backend.isOpen()).toBe(false);
|
||||
expect(await backend.read('k')).toBeNull();
|
||||
await backend.write('late', enc('x')); // 静默忽略
|
||||
await backend.append('late2', enc('x'));
|
||||
await backend.writeMany({ a: enc('1') });
|
||||
await backend.delete('k');
|
||||
await backend.deleteMany(['a']);
|
||||
expect(await backend.listKeys()).toEqual([]);
|
||||
expect(await backend.exists('k')).toBe(false);
|
||||
await backend.clear();
|
||||
await backend.cleanupStaleFiles();
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,62 @@
|
||||
/**
|
||||
* AriaEngine Page — 页面核心逻辑测试
|
||||
*
|
||||
* v0.4.5: 页面层精简后仅保留生产代码实际使用的函数：
|
||||
* - initPageHeader（FileManager 创建空页面）
|
||||
* - createPage（BufferPool 分配新页面）
|
||||
* - PAGE_HEADER_SIZE / PAGE_SIZE 常量
|
||||
* 页面内容为 SSTable 原始字节切片（PageSSTableStore 管理），无行级 slot 结构。
|
||||
*/
|
||||
import { createPage } from '../../src/engine/aria/page/format';
|
||||
import { initPageHeader } from '../../src/engine/aria/page/header';
|
||||
import { PAGE_SIZE, PAGE_HEADER_SIZE, PageType } from '../../src/engine/aria/types';
|
||||
|
||||
describe('AriaEngine — Page 核心', () => {
|
||||
it('initPageHeader 初始化 4KB 页面头部字段', () => {
|
||||
const buf = new ArrayBuffer(PAGE_SIZE);
|
||||
initPageHeader(buf, 42, PageType.DATA);
|
||||
const view = new DataView(buf);
|
||||
expect(view.getUint32(0, false)).toBe(42); // page_id
|
||||
expect(view.getUint8(4)).toBe(PageType.DATA); // type
|
||||
expect(view.getUint16(5, false)).toBe(PAGE_HEADER_SIZE); // free_start
|
||||
expect(view.getUint16(7, false)).toBe(PAGE_SIZE); // free_end
|
||||
expect(view.getUint16(9, false)).toBe(0); // slot_count
|
||||
expect(view.getUint8(15)).toBe(0); // reserved
|
||||
});
|
||||
|
||||
it('initPageHeader 支持不同页面类型', () => {
|
||||
const buf = new ArrayBuffer(PAGE_SIZE);
|
||||
initPageHeader(buf, 1, PageType.META);
|
||||
expect(new DataView(buf).getUint8(4)).toBe(PageType.META);
|
||||
});
|
||||
|
||||
it('createPage 创建脏页面（pins=0，初始化头部）', () => {
|
||||
const page = createPage(7, PageType.DATA);
|
||||
expect(page.pageId).toBe(7);
|
||||
expect(page.type).toBe(PageType.DATA);
|
||||
expect(page.data.byteLength).toBe(PAGE_SIZE);
|
||||
expect(page.dirty).toBe(true);
|
||||
expect(page.pins).toBe(0);
|
||||
// 头部已初始化
|
||||
expect(new DataView(page.data).getUint32(0, false)).toBe(7);
|
||||
expect(new DataView(page.data).getUint8(4)).toBe(PageType.DATA);
|
||||
});
|
||||
|
||||
it('页面数据区从头部之后开始（跳过 16 字节头）', () => {
|
||||
const page = createPage(1, PageType.DATA);
|
||||
// 头部之后写入数据，头部字段不受影响
|
||||
const view = new Uint8Array(page.data);
|
||||
view[PAGE_HEADER_SIZE] = 0xAB;
|
||||
view[PAGE_HEADER_SIZE + 1] = 0xCD;
|
||||
expect(view[PAGE_HEADER_SIZE]).toBe(0xAB);
|
||||
expect(view[PAGE_HEADER_SIZE + 1]).toBe(0xCD);
|
||||
// 头部字段保持
|
||||
expect(new DataView(page.data).getUint32(0, false)).toBe(1);
|
||||
});
|
||||
|
||||
it('createPage 的 dirty 标记在写入后保持（PageSSTableStore 依赖）', () => {
|
||||
const page = createPage(2, PageType.DATA);
|
||||
new Uint8Array(page.data)[100] = 0x01;
|
||||
expect(page.dirty).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,318 @@
|
||||
/**
|
||||
* AriaEngine — 页面化 SSTable 存储测试
|
||||
*
|
||||
* 覆盖：
|
||||
* 1. PageSSTableStore 单元：save/load 往返（页边界、非整数页）、delete 释放页面
|
||||
* 2. AriaEngine + OPFS（页面模式）：写入 → flush → close → reopen 数据完整
|
||||
* 3. 大 SSTable 多页 + pageIds 注入 meta 验证
|
||||
* 4. 页面损坏（CRC 校验失败）→ 打开自愈清理
|
||||
* 5. 页面模式与非页面模式混合（pageIds 兼容：新页面写 + 旧整 value 读）
|
||||
* 6. 页面化 + 加密 + 压缩组合
|
||||
*/
|
||||
import { AriaEngine } from '../../src/engine/aria/index';
|
||||
import { PageSSTableStore } from '../../src/engine/aria/store/page_sstable_store';
|
||||
import { FileManager } from '../../src/engine/aria/store/file_manager';
|
||||
import { BufferPool } from '../../src/engine/aria/buffer/pool';
|
||||
import { MemoryBackend } from '../../src/engine/aria/store/backend';
|
||||
import { createSchema } from '../../src/table/schema';
|
||||
import { PAGE_SIZE } from '../../src/engine/aria/types';
|
||||
|
||||
// ===================================================================
|
||||
// OPFS mock（共享工具）
|
||||
// ===================================================================
|
||||
import { installOPFSMock } from '../helpers/opfs-mock';
|
||||
|
||||
const SCHEMA = () => createSchema('users', {
|
||||
id: { type: 'string', primaryKey: true },
|
||||
name: { type: 'string' },
|
||||
note: { type: 'string' },
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// PageSSTableStore 单元
|
||||
// ===================================================================
|
||||
describe('AriaEngine — PageSSTableStore 单元', () => {
|
||||
it('save/load 往返：单页数据', async () => {
|
||||
const backend = new MemoryBackend();
|
||||
await backend.open('pg-unit-1');
|
||||
const fm = new FileManager(backend);
|
||||
await fm.init('pg-unit-1');
|
||||
const bp = new BufferPool(fm, 64);
|
||||
const store = new PageSSTableStore(fm, bp);
|
||||
|
||||
const data = new Uint8Array(new TextEncoder().encode('hello page store'));
|
||||
await store.save(1, data);
|
||||
const pageIds = store.getPageIds(1)!;
|
||||
expect(pageIds.length).toBe(1);
|
||||
|
||||
const back = await store.load(1, pageIds, data.byteLength);
|
||||
expect(back).not.toBeNull();
|
||||
expect(new TextDecoder().decode(back)).toBe('hello page store');
|
||||
|
||||
// 页面已落盘（backend 有 pg_ 键）
|
||||
expect(await backend.exists('pg_1')).toBe(true);
|
||||
|
||||
await store.delete(1, pageIds);
|
||||
expect(await backend.exists('pg_1')).toBe(false);
|
||||
await backend.close();
|
||||
});
|
||||
|
||||
it('save/load 往返：多页数据（跨 4KB 边界）', async () => {
|
||||
const backend = new MemoryBackend();
|
||||
await backend.open('pg-unit-2');
|
||||
const fm = new FileManager(backend);
|
||||
await fm.init('pg-unit-2');
|
||||
const bp = new BufferPool(fm, 64);
|
||||
const store = new PageSSTableStore(fm, bp);
|
||||
|
||||
// 3 页：4KB * 2 + 1KB
|
||||
const size = PAGE_SIZE * 2 + 1024;
|
||||
const data = new Uint8Array(size);
|
||||
let x = 42;
|
||||
for (let i = 0; i < size; i++) {
|
||||
x = (x * 31 + 7) & 0xffff;
|
||||
data[i] = x & 0xff;
|
||||
}
|
||||
await store.save(7, data);
|
||||
const pageIds = store.getPageIds(7)!;
|
||||
expect(pageIds.length).toBe(3);
|
||||
|
||||
const back = await store.load(7, pageIds, size);
|
||||
expect(back).not.toBeNull();
|
||||
expect(back!.byteLength).toBe(size);
|
||||
expect(back).toEqual(data);
|
||||
await backend.close();
|
||||
});
|
||||
|
||||
it('load 使用 totalSize 截断最后一页的 0 填充', async () => {
|
||||
const backend = new MemoryBackend();
|
||||
await backend.open('pg-unit-3');
|
||||
const fm = new FileManager(backend);
|
||||
await fm.init('pg-unit-3');
|
||||
const bp = new BufferPool(fm, 64);
|
||||
const store = new PageSSTableStore(fm, bp);
|
||||
|
||||
// 非整数页：4096 + 100 字节
|
||||
const real = new Uint8Array(PAGE_SIZE + 100);
|
||||
for (let i = 0; i < real.length; i++) real[i] = i & 0xff;
|
||||
await store.save(9, real);
|
||||
const pageIds = store.getPageIds(9)!;
|
||||
expect(pageIds.length).toBe(2);
|
||||
|
||||
const back = await store.load(9, pageIds, real.length);
|
||||
expect(back!.byteLength).toBe(real.length);
|
||||
expect(back).toEqual(real);
|
||||
await backend.close();
|
||||
});
|
||||
|
||||
it('页面缺失（磁盘文件丢失 + 缓存清空）→ load 返回 null', async () => {
|
||||
const backend = new MemoryBackend();
|
||||
await backend.open('pg-unit-4');
|
||||
const fm = new FileManager(backend);
|
||||
await fm.init('pg-unit-4');
|
||||
const bp = new BufferPool(fm, 64);
|
||||
const store = new PageSSTableStore(fm, bp);
|
||||
|
||||
await store.save(5, new Uint8Array(100));
|
||||
const pageIds = store.getPageIds(5)!;
|
||||
// 模拟崩溃重开：磁盘文件丢失 + 页面缓存清空
|
||||
await backend.delete('pg_' + pageIds[0]);
|
||||
bp.removePage(pageIds[0]);
|
||||
|
||||
const back = await store.load(5, pageIds, 100);
|
||||
expect(back).toBeNull();
|
||||
await backend.close();
|
||||
});
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// AriaEngine + OPFS 页面模式集成
|
||||
// ===================================================================
|
||||
describe('AriaEngine — 页面化 SSTable 集成（OPFS）', () => {
|
||||
it('写入 → flush → close → reopen 数据完整（页面模式默认启用）', async () => {
|
||||
const files = installOPFSMock(new Map());
|
||||
const engine = new AriaEngine({
|
||||
storageBackend: 'opfs',
|
||||
memtableSizeThreshold: 64 * 1024 * 1024,
|
||||
checkpointInterval: 100000,
|
||||
});
|
||||
await engine.open('page-db-1', 1);
|
||||
await engine.createTable(SCHEMA());
|
||||
|
||||
// 多行 + 大 note → 超过 4KB → 多页
|
||||
const rows = [] as Record<string, unknown>[];
|
||||
for (let i = 0; i < 30; i++) {
|
||||
rows.push({ id: `u-${i}`, name: `User${i}`, note: 'page-store-note-'.repeat(40) });
|
||||
}
|
||||
await engine.insert('users', rows);
|
||||
await (engine as any).lsm.flush();
|
||||
|
||||
// 页面化落盘：backend 有 pg_ 键，meta 含 pageIds
|
||||
const backend = (engine as any).backend;
|
||||
const keys = await backend.listKeys();
|
||||
const pgKeys = keys.filter((k: string) => k.startsWith('pg_'));
|
||||
const sstKeys = keys.filter((k: string) => k.startsWith('sst_'));
|
||||
expect(pgKeys.length).toBeGreaterThan(0);
|
||||
expect(sstKeys.length).toBe(0); // 页面模式下不写整 value SSTable
|
||||
|
||||
const metas = await (engine as any).lsm.sstableStore.listMeta();
|
||||
expect(metas.length).toBeGreaterThan(0);
|
||||
expect(metas[0].pageIds).toBeDefined();
|
||||
expect(metas[0].pageIds.length).toBeGreaterThan(0);
|
||||
|
||||
await engine.close();
|
||||
|
||||
// reopen：数据完整
|
||||
const engine2 = new AriaEngine({ storageBackend: 'opfs', checkpointInterval: 100000 });
|
||||
await engine2.open('page-db-1', 1);
|
||||
const found = await engine2.find('users', { table: 'users' });
|
||||
expect(found).toHaveLength(30);
|
||||
expect(found[0].note).toBe('page-store-note-'.repeat(40));
|
||||
expect(await engine2.count('users')).toBe(30);
|
||||
await engine2.close();
|
||||
});
|
||||
|
||||
it('多级 compaction 后页面化数据仍完整', async () => {
|
||||
const files = installOPFSMock(new Map());
|
||||
const engine = new AriaEngine({
|
||||
storageBackend: 'opfs',
|
||||
memtableSizeThreshold: 16 * 1024,
|
||||
checkpointInterval: 100000,
|
||||
});
|
||||
await engine.open('page-db-2', 1);
|
||||
await engine.createTable(SCHEMA());
|
||||
|
||||
// 大量小批量写入 → 多次 flush → 触发 compaction
|
||||
for (let batch = 0; batch < 8; batch++) {
|
||||
const rows = [] as Record<string, unknown>[];
|
||||
for (let i = 0; i < 20; i++) {
|
||||
rows.push({ id: `b${batch}-u${i}`, name: `U${i}`, note: 'x'.repeat(200) });
|
||||
}
|
||||
await engine.insert('users', rows);
|
||||
await (engine as any).lsm.flush();
|
||||
}
|
||||
// 强制压缩
|
||||
await (engine as any).lsm.compactLevel(0);
|
||||
|
||||
await engine.close();
|
||||
const engine2 = new AriaEngine({ storageBackend: 'opfs', checkpointInterval: 100000 });
|
||||
await engine2.open('page-db-2', 1);
|
||||
expect(await engine2.count('users')).toBe(160);
|
||||
const one = await engine2.find('users', { table: 'users', where: { id: 'b3-u10' } });
|
||||
expect(one).toHaveLength(1);
|
||||
await engine2.close();
|
||||
});
|
||||
|
||||
it('页面损坏（篡改 pg_ 文件）→ 打开自愈清理，其余数据可读', async () => {
|
||||
const files = installOPFSMock(new Map());
|
||||
const engine = new AriaEngine({
|
||||
storageBackend: 'opfs',
|
||||
memtableSizeThreshold: 64 * 1024 * 1024,
|
||||
checkpointInterval: 100000,
|
||||
});
|
||||
await engine.open('page-db-3', 1);
|
||||
await engine.createTable(SCHEMA());
|
||||
for (let batch = 0; batch < 2; batch++) {
|
||||
const rows = [] as Record<string, unknown>[];
|
||||
for (let i = 0; i < 20; i++) {
|
||||
rows.push({ id: `b${batch}-u${i}`, name: `U${i}`, note: 'n'.repeat(100) });
|
||||
}
|
||||
await engine.insert('users', rows);
|
||||
await (engine as any).lsm.flush();
|
||||
}
|
||||
await engine.close();
|
||||
|
||||
// 篡改第一个 SSTable 的第一页
|
||||
const engine2 = new AriaEngine({ storageBackend: 'opfs', checkpointInterval: 100000 });
|
||||
await engine2.open('page-db-3', 1);
|
||||
const metas = await (engine2 as any).lsm.sstableStore.listMeta();
|
||||
expect(metas.length).toBeGreaterThanOrEqual(2);
|
||||
const victim = metas[0];
|
||||
const backend = (engine2 as any).backend;
|
||||
const pageRaw = await backend.read(`pg_${victim.pageIds[0]}`);
|
||||
const corrupted = new Uint8Array(pageRaw);
|
||||
corrupted[100] ^= 0xff;
|
||||
await backend.write(`pg_${victim.pageIds[0]}`, corrupted.buffer as ArrayBuffer);
|
||||
await engine2.close();
|
||||
|
||||
// 重开：损坏页面的 SSTable 被清理，其余数据可读
|
||||
const engine3 = new AriaEngine({ storageBackend: 'opfs', checkpointInterval: 100000 });
|
||||
await engine3.open('page-db-3', 1);
|
||||
const rows3 = await engine3.find('users', { table: 'users' });
|
||||
expect(rows3.length).toBeGreaterThan(0);
|
||||
expect(rows3.length).toBeLessThan(40);
|
||||
await engine3.close();
|
||||
});
|
||||
|
||||
it('页面模式与非页面模式混合兼容（pageIds 缺失 → 整 value 读取）', async () => {
|
||||
const { files } = installOPFSMock(new Map());
|
||||
// 阶段 1：非页面模式写入（pageStorage: false → 整 value SSTable）
|
||||
const engine = new AriaEngine({
|
||||
storageBackend: 'opfs',
|
||||
pageStorage: false,
|
||||
memtableSizeThreshold: 64 * 1024 * 1024,
|
||||
checkpointInterval: 100000,
|
||||
});
|
||||
await engine.open('page-db-4', 1);
|
||||
await engine.createTable(SCHEMA());
|
||||
await engine.insert('users', [{ id: 'legacy-1', name: 'Old', note: 'whole-value' }]);
|
||||
await (engine as any).lsm.flush();
|
||||
await engine.close();
|
||||
|
||||
const backendKeys1 = Array.from(files.keys());
|
||||
expect(backendKeys1.some((k) => k.startsWith('sst_'))).toBe(true);
|
||||
|
||||
// 阶段 2：页面模式打开（默认 opfs → 启用），读旧数据 + 写新数据
|
||||
const engine2 = new AriaEngine({ storageBackend: 'opfs', checkpointInterval: 100000 });
|
||||
await engine2.open('page-db-4', 1);
|
||||
expect(await engine2.count('users')).toBe(1);
|
||||
const legacy = await engine2.find('users', { table: 'users', where: { id: 'legacy-1' } });
|
||||
expect(legacy[0].note).toBe('whole-value');
|
||||
// 新写入 → 页面化
|
||||
await engine2.insert('users', [{ id: 'new-1', name: 'New', note: 'paged' }]);
|
||||
await (engine2 as any).lsm.flush();
|
||||
await engine2.close();
|
||||
|
||||
// 阶段 3：混合库重开，新旧数据都在
|
||||
const engine3 = new AriaEngine({ storageBackend: 'opfs', checkpointInterval: 100000 });
|
||||
await engine3.open('page-db-4', 1);
|
||||
expect(await engine3.count('users')).toBe(2);
|
||||
const both = await engine3.find('users', { table: 'users' });
|
||||
const byId = Object.fromEntries(both.map((r) => [r.id, r]));
|
||||
expect(byId['legacy-1'].note).toBe('whole-value');
|
||||
expect(byId['new-1'].note).toBe('paged');
|
||||
await engine3.close();
|
||||
});
|
||||
|
||||
it('页面化 + 加密 + 压缩组合：往返完整', async () => {
|
||||
const files = installOPFSMock(new Map());
|
||||
const engine = new AriaEngine({
|
||||
storageBackend: 'opfs',
|
||||
compression: true,
|
||||
encryption: { password: 'page-pass' },
|
||||
memtableSizeThreshold: 64 * 1024 * 1024,
|
||||
checkpointInterval: 100000,
|
||||
});
|
||||
await engine.open('page-db-5', 1);
|
||||
await engine.createTable(SCHEMA());
|
||||
const rows = [] as Record<string, unknown>[];
|
||||
for (let i = 0; i < 20; i++) {
|
||||
rows.push({ id: `e-${i}`, name: `E${i}`, note: '加密的页面化内容'.repeat(30) });
|
||||
}
|
||||
await engine.insert('users', rows);
|
||||
await (engine as any).lsm.flush();
|
||||
await engine.close();
|
||||
|
||||
const engine2 = new AriaEngine({
|
||||
storageBackend: 'opfs',
|
||||
compression: true,
|
||||
encryption: { password: 'page-pass' },
|
||||
checkpointInterval: 100000,
|
||||
});
|
||||
await engine2.open('page-db-5', 1);
|
||||
expect(await engine2.count('users')).toBe(20);
|
||||
const one = await engine2.find('users', { table: 'users', where: { id: 'e-7' } });
|
||||
expect(one[0].note).toBe('加密的页面化内容'.repeat(30));
|
||||
await engine2.close();
|
||||
});
|
||||
});
|
||||
@@ -1,337 +0,0 @@
|
||||
/**
|
||||
* AriaEngine Page 格式单元测试
|
||||
* 覆盖: PageHeader / Slot / Tuple 编解码 + PageFormat 整合
|
||||
*/
|
||||
import {
|
||||
PAGE_SIZE, PageType, PAGE_HEADER_SIZE, SLOT_ENTRY_SIZE,
|
||||
} from '../../src/engine/aria/types';
|
||||
import {
|
||||
encodePageHeader, decodePageHeader, initPageHeader, getPageType,
|
||||
getSlotCount, getFreeStart, setFreeStart, setFreeEnd,
|
||||
} from '../../src/engine/aria/page/header';
|
||||
import {
|
||||
getSlotEntry, setSlotEntry, getSlotDirectorySize,
|
||||
getFreeSpace, hasEnoughSpace, allocateSlot, readSlotData, freeSlot,
|
||||
} from '../../src/engine/aria/page/slot';
|
||||
import {
|
||||
encodeTuple, decodeTuple, getColumnEncodingMap,
|
||||
} from '../../src/engine/aria/page/tuple';
|
||||
import { ColumnEncoding } from '../../src/engine/aria/types';
|
||||
import {
|
||||
createPage, pageFromBuffer, pageInsertRow, pageReadRow,
|
||||
pageDeleteRow, pageUpdateRow, computeChecksum, verifyChecksum, updateChecksum,
|
||||
} from '../../src/engine/aria/page/format';
|
||||
|
||||
// ===================================================================
|
||||
// PageHeader
|
||||
// ===================================================================
|
||||
describe('AriaEngine Page — Header', () => {
|
||||
let buf: ArrayBuffer;
|
||||
|
||||
beforeEach(() => {
|
||||
buf = new ArrayBuffer(PAGE_SIZE);
|
||||
});
|
||||
|
||||
it('initPageHeader 初始化头部字段', () => {
|
||||
initPageHeader(buf, 42, PageType.DATA);
|
||||
const h = decodePageHeader(buf);
|
||||
expect(h.pageId).toBe(42);
|
||||
expect(h.type).toBe(PageType.DATA);
|
||||
expect(h.slotCount).toBe(0);
|
||||
expect(h.freeStart).toBe(PAGE_HEADER_SIZE);
|
||||
expect(h.freeEnd).toBe(PAGE_SIZE);
|
||||
});
|
||||
|
||||
it('initPageHeader — INDEX 类型页面', () => {
|
||||
initPageHeader(buf, 99, PageType.INDEX);
|
||||
expect(getPageType(buf)).toBe(PageType.INDEX);
|
||||
});
|
||||
|
||||
it('encodePageHeader + decodePageHeader 往返一致', () => {
|
||||
const header = { pageId: 7, type: PageType.META, freeStart: 32, freeEnd: 4000, slotCount: 5, checksum: 0xdeadbeef };
|
||||
encodePageHeader(header, buf);
|
||||
const decoded = decodePageHeader(buf);
|
||||
expect(decoded.pageId).toBe(7);
|
||||
expect(decoded.type).toBe(PageType.META);
|
||||
expect(decoded.freeStart).toBe(32);
|
||||
expect(decoded.freeEnd).toBe(4000);
|
||||
expect(decoded.slotCount).toBe(5);
|
||||
});
|
||||
|
||||
it('不同 pageId 正确编解码', () => {
|
||||
for (const id of [0, 1, 255, 65535, 0xffffffff]) {
|
||||
initPageHeader(buf, id, PageType.DATA);
|
||||
expect(decodePageHeader(buf).pageId).toBe(id >>> 0);
|
||||
}
|
||||
});
|
||||
|
||||
it('setFreeStart / setFreeEnd 修改字段', () => {
|
||||
initPageHeader(buf, 1, PageType.DATA);
|
||||
setFreeStart(buf, 100);
|
||||
setFreeEnd(buf, 3000);
|
||||
expect(getFreeStart(buf)).toBe(100);
|
||||
expect(decodePageHeader(buf).freeEnd).toBe(3000);
|
||||
});
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// Slot Directory
|
||||
// ===================================================================
|
||||
describe('AriaEngine Page — Slot', () => {
|
||||
let buf: ArrayBuffer;
|
||||
|
||||
beforeEach(() => {
|
||||
buf = new ArrayBuffer(PAGE_SIZE);
|
||||
initPageHeader(buf, 1, PageType.DATA);
|
||||
});
|
||||
|
||||
it('getSlotEntry — 空页面 slotCount 为 0', () => {
|
||||
expect(getSlotCount(buf)).toBe(0);
|
||||
});
|
||||
|
||||
it('setSlotEntry + getSlotEntry 往返', () => {
|
||||
// 手动写一个 slot（不通过 allocateSlot）
|
||||
new DataView(buf).setUint16(9, 1, false); // slotCount = 1
|
||||
setSlotEntry(buf, 0, { offset: 1000, length: 50 });
|
||||
const entry = getSlotEntry(buf, 0);
|
||||
expect(entry.offset).toBe(1000);
|
||||
expect(entry.length).toBe(50);
|
||||
});
|
||||
|
||||
it('getSlotDirectorySize 计算正确', () => {
|
||||
expect(getSlotDirectorySize(0)).toBe(0);
|
||||
expect(getSlotDirectorySize(1)).toBe(SLOT_ENTRY_SIZE);
|
||||
expect(getSlotDirectorySize(10)).toBe(10 * SLOT_ENTRY_SIZE);
|
||||
});
|
||||
|
||||
it('getFreeSpace — 空页面有最大空闲空间', () => {
|
||||
const free = getFreeSpace(buf);
|
||||
expect(free).toBe(PAGE_SIZE - PAGE_HEADER_SIZE);
|
||||
});
|
||||
|
||||
it('hasEnoughSpace — 小数据返回 true', () => {
|
||||
expect(hasEnoughSpace(buf, 100)).toBe(true);
|
||||
});
|
||||
|
||||
it('hasEnoughSpace — 超大数据返回 false', () => {
|
||||
expect(hasEnoughSpace(buf, PAGE_SIZE * 2)).toBe(false);
|
||||
});
|
||||
|
||||
it('allocateSlot 分配并写入数据', () => {
|
||||
const data = new Uint8Array([1, 2, 3, 4, 5]);
|
||||
const idx = allocateSlot(buf, data);
|
||||
expect(idx).toBe(0);
|
||||
expect(getSlotCount(buf)).toBe(1);
|
||||
|
||||
const readBack = readSlotData(buf, 0);
|
||||
expect(readBack).not.toBeNull();
|
||||
expect(Array.from(readBack!)).toEqual([1, 2, 3, 4, 5]);
|
||||
});
|
||||
|
||||
it('allocateSlot 多次分配', () => {
|
||||
for (let i = 0; i < 10; i++) {
|
||||
const data = new Uint8Array([i, i + 1]);
|
||||
const idx = allocateSlot(buf, data);
|
||||
expect(idx).toBe(i);
|
||||
}
|
||||
expect(getSlotCount(buf)).toBe(10);
|
||||
|
||||
// 验证每个 slot 数据正确
|
||||
for (let i = 0; i < 10; i++) {
|
||||
const data = readSlotData(buf, i);
|
||||
expect(Array.from(data!)).toEqual([i, i + 1]);
|
||||
}
|
||||
});
|
||||
|
||||
it('freeSlot 标记为删除', () => {
|
||||
const data = new Uint8Array([10, 20, 30]);
|
||||
allocateSlot(buf, data);
|
||||
freeSlot(buf, 0);
|
||||
const entry = getSlotEntry(buf, 0);
|
||||
expect(entry.offset).toBe(0);
|
||||
expect(entry.length).toBe(0);
|
||||
});
|
||||
|
||||
it('readSlotData — 已删除 slot 返回 null', () => {
|
||||
allocateSlot(buf, new Uint8Array([1]));
|
||||
freeSlot(buf, 0);
|
||||
expect(readSlotData(buf, 0)).toBeNull();
|
||||
});
|
||||
|
||||
it('allocateSlot — 空间不足返回 -1', () => {
|
||||
// 填满页面
|
||||
const big = new Uint8Array(PAGE_SIZE - PAGE_HEADER_SIZE - SLOT_ENTRY_SIZE);
|
||||
const idx1 = allocateSlot(buf, big);
|
||||
expect(idx1).toBe(0);
|
||||
const idx2 = allocateSlot(buf, new Uint8Array([1]));
|
||||
expect(idx2).toBe(-1);
|
||||
});
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// Tuple Codec
|
||||
// ===================================================================
|
||||
describe('AriaEngine Page — Tuple', () => {
|
||||
const colOrder = ['id', 'name', 'age', 'active', 'data'];
|
||||
const colTypes: Record<string, string> = {
|
||||
id: 'string', name: 'string', age: 'number', active: 'boolean', data: 'json',
|
||||
};
|
||||
|
||||
it('encodeTuple + decodeTuple 完整往返', () => {
|
||||
const row = { id: '1', name: 'Alice', age: 30, active: true, data: { x: 1 } };
|
||||
const encoded = encodeTuple(row, colOrder, colTypes);
|
||||
expect(encoded.byteLength).toBeGreaterThan(0);
|
||||
|
||||
const decoded = decodeTuple(encoded, colOrder, colTypes);
|
||||
expect(decoded).not.toBeNull();
|
||||
expect(decoded!.id).toBe('1');
|
||||
expect(decoded!.name).toBe('Alice');
|
||||
expect(decoded!.age).toBe(30);
|
||||
expect(decoded!.active).toBe(true);
|
||||
expect(decoded!.data).toEqual({ x: 1 });
|
||||
});
|
||||
|
||||
it('encodeTuple — null 值正确处理', () => {
|
||||
const row = { id: '2', name: null, age: 25, active: null, data: null };
|
||||
const encoded = encodeTuple(row, colOrder, colTypes);
|
||||
const decoded = decodeTuple(encoded, colOrder, colTypes);
|
||||
expect(decoded!.name).toBeNull();
|
||||
expect(decoded!.active).toBeNull();
|
||||
expect(decoded!.data).toBeNull();
|
||||
});
|
||||
|
||||
it('encodeTuple — undefined 值按 null 处理', () => {
|
||||
const row = { id: '3', age: 30 } as any;
|
||||
const encoded = encodeTuple(row, colOrder, colTypes);
|
||||
const decoded = decodeTuple(encoded, colOrder, colTypes);
|
||||
expect(decoded!.id).toBe('3');
|
||||
expect(decoded!.name).toBeNull();
|
||||
});
|
||||
|
||||
it('encodeTuple — date 类型', () => {
|
||||
const order = ['ts'];
|
||||
const types = { ts: 'date' };
|
||||
const row = { ts: '2024-01-15T00:00:00.000Z' };
|
||||
const encoded = encodeTuple(row, order, types);
|
||||
const decoded = decodeTuple(encoded, order, types);
|
||||
expect(decoded!.ts).toBe('2024-01-15T00:00:00.000Z');
|
||||
});
|
||||
|
||||
it('encodeTuple — boolean false', () => {
|
||||
const order = ['flag'];
|
||||
const types = { flag: 'boolean' };
|
||||
const encoded = encodeTuple({ flag: false }, order, types);
|
||||
const decoded = decodeTuple(encoded, order, types);
|
||||
expect(decoded!.flag).toBe(false);
|
||||
});
|
||||
|
||||
it('encodeTuple — 负数', () => {
|
||||
const order = ['val'];
|
||||
const types = { val: 'number' };
|
||||
const encoded = encodeTuple({ val: -42.5 }, order, types);
|
||||
const decoded = decodeTuple(encoded, order, types);
|
||||
expect(decoded!.val).toBe(-42.5);
|
||||
});
|
||||
|
||||
it('encodeTuple — 空字符串', () => {
|
||||
const order = ['s'];
|
||||
const types = { s: 'string' };
|
||||
const encoded = encodeTuple({ s: '' }, order, types);
|
||||
const decoded = decodeTuple(encoded, order, types);
|
||||
expect(decoded!.s).toBe('');
|
||||
});
|
||||
|
||||
it('encodeTuple — 长字符串', () => {
|
||||
const order = ['s'];
|
||||
const types = { s: 'string' };
|
||||
const long = 'x'.repeat(10000);
|
||||
const encoded = encodeTuple({ s: long }, order, types);
|
||||
const decoded = decodeTuple(encoded, order, types);
|
||||
expect(decoded!.s).toBe(long);
|
||||
});
|
||||
|
||||
it('getColumnEncodingMap 返回正确映射', () => {
|
||||
const map = getColumnEncodingMap(colOrder, colTypes);
|
||||
expect(map.get('id')).toBe(ColumnEncoding.STRING);
|
||||
expect(map.get('age')).toBe(ColumnEncoding.NUMBER);
|
||||
expect(map.get('active')).toBe(ColumnEncoding.BOOLEAN);
|
||||
expect(map.get('data')).toBe(ColumnEncoding.JSON);
|
||||
});
|
||||
|
||||
it('decodeTuple — 损坏数据返回 null', () => {
|
||||
const broken = new Uint8Array([0xff, 0xff, 0xff]);
|
||||
expect(decodeTuple(broken, colOrder, colTypes)).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// Page Format 整合
|
||||
// ===================================================================
|
||||
describe('AriaEngine Page — Format', () => {
|
||||
const colOrder = ['id', 'name'];
|
||||
const colTypes: Record<string, string> = { id: 'string', name: 'string' };
|
||||
|
||||
it('createPage 创建合法页面', () => {
|
||||
const page = createPage(100, PageType.DATA);
|
||||
expect(page.pageId).toBe(100);
|
||||
expect(page.type).toBe(PageType.DATA);
|
||||
expect(page.pins).toBe(0);
|
||||
expect(page.dirty).toBe(true);
|
||||
});
|
||||
|
||||
it('pageInsertRow + pageReadRow 往返', () => {
|
||||
const page = createPage(1, PageType.DATA);
|
||||
const row = { id: 'u1', name: 'Test' };
|
||||
const idx = pageInsertRow(page, row, colOrder, colTypes);
|
||||
expect(idx).toBe(0);
|
||||
|
||||
const read = pageReadRow(page, 0, colOrder, colTypes);
|
||||
expect(read).not.toBeNull();
|
||||
expect(read!.id).toBe('u1');
|
||||
expect(read!.name).toBe('Test');
|
||||
});
|
||||
|
||||
it('pageInsertRow — 多次插入', () => {
|
||||
const page = createPage(1, PageType.DATA);
|
||||
for (let i = 0; i < 50; i++) {
|
||||
const idx = pageInsertRow(page, { id: `${i}`, name: `User${i}` }, colOrder, colTypes);
|
||||
expect(idx).toBe(i);
|
||||
}
|
||||
for (let i = 0; i < 50; i++) {
|
||||
const row = pageReadRow(page, i, colOrder, colTypes);
|
||||
expect(row!.id).toBe(`${i}`);
|
||||
}
|
||||
});
|
||||
|
||||
it('pageDeleteRow 标记删除', () => {
|
||||
const page = createPage(1, PageType.DATA);
|
||||
pageInsertRow(page, { id: '1', name: 'A' }, colOrder, colTypes);
|
||||
pageInsertRow(page, { id: '2', name: 'B' }, colOrder, colTypes);
|
||||
pageDeleteRow(page, 0);
|
||||
expect(page.dirty).toBe(true);
|
||||
// 已删除的行读取失败
|
||||
const row = pageReadRow(page, 0, colOrder, colTypes);
|
||||
expect(row).toBeNull();
|
||||
// 未删除的行仍然可读
|
||||
const row2 = pageReadRow(page, 1, colOrder, colTypes);
|
||||
expect(row2!.id).toBe('2');
|
||||
});
|
||||
|
||||
it('pageFromBuffer 从 ArrayBuffer 恢复', () => {
|
||||
const page = createPage(5, PageType.INDEX);
|
||||
const restored = pageFromBuffer(5, page.data);
|
||||
expect(restored.pageId).toBe(5);
|
||||
expect(restored.type).toBe(PageType.INDEX);
|
||||
expect(restored.dirty).toBe(false);
|
||||
});
|
||||
|
||||
it('computeChecksum + verifyChecksum', () => {
|
||||
const page = createPage(1, PageType.DATA);
|
||||
updateChecksum(page);
|
||||
expect(verifyChecksum(page)).toBe(true);
|
||||
|
||||
// 修改页面 → 校验和失效
|
||||
new Uint8Array(page.data)[100] = 0xff;
|
||||
expect(verifyChecksum(page)).toBe(false);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,249 @@
|
||||
/**
|
||||
* AriaEngine — repair 自愈增强 + 随机操作压力测试
|
||||
*
|
||||
* 覆盖：
|
||||
* 1. repair 清理孤儿页面（meta 未引用的 pg_ 文件）
|
||||
* 2. repair 清理 OPFS 残留临时文件
|
||||
* 3. WAL 空洞 + repair → 截断清空（不再重放错位数据）
|
||||
* 4. 随机操作压力：insert/update/delete + 模拟崩溃（不 checkpoint 断开）→ 重开全量验证
|
||||
* 5. 随机操作 + 页面化 + 模拟崩溃 → 重开验证
|
||||
* 6. repair 幂等
|
||||
*/
|
||||
import { AriaEngine } from '../../src/engine/aria/index';
|
||||
import { createSchema } from '../../src/table/schema';
|
||||
import { installOPFSMock } from '../helpers/opfs-mock';
|
||||
import 'fake-indexeddb/auto';
|
||||
|
||||
let idbCounter = 0;
|
||||
function uniqueDB(): string {
|
||||
return `rph-${Date.now()}-${++idbCounter}-${Math.random().toString(36).slice(2, 8)}`;
|
||||
}
|
||||
|
||||
const SCHEMA = () => createSchema('items', {
|
||||
id: { type: 'string', primaryKey: true },
|
||||
val: { type: 'number' },
|
||||
tag: { type: 'string', index: true },
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// repair 增强
|
||||
// ===================================================================
|
||||
describe('AriaEngine — repair 自愈增强', () => {
|
||||
it('清理孤儿页面（meta 未引用的 pg_ 文件）', async () => {
|
||||
const dbName = uniqueDB();
|
||||
const engine = new AriaEngine({
|
||||
storageBackend: 'indexeddb',
|
||||
pageStorage: true, // 强制页面化（IDB 上也启用，便于断言页面文件）
|
||||
memtableSizeThreshold: 64 * 1024 * 1024,
|
||||
checkpointInterval: 100000,
|
||||
});
|
||||
await engine.open(dbName, 1);
|
||||
await engine.createTable(SCHEMA());
|
||||
await engine.insert('items', [{ id: 'a', val: 1, tag: 'x' }]);
|
||||
await (engine as any).lsm.flush();
|
||||
|
||||
const backend = (engine as any).backend;
|
||||
const keys = await backend.listKeys();
|
||||
const pgKeys = keys.filter((k: string) => k.startsWith('pg_'));
|
||||
expect(pgKeys.length).toBeGreaterThan(0);
|
||||
|
||||
// 伪造孤儿页面（模拟崩溃中断的删除流程）
|
||||
await backend.write('pg_999999', new Uint8Array(4096).buffer);
|
||||
await backend.write('pg_999998', new Uint8Array(4096).buffer);
|
||||
expect((await backend.listKeys()).filter((k: string) => k.startsWith('pg_99999'))).toHaveLength(2);
|
||||
|
||||
await (engine as any).repair();
|
||||
|
||||
// 孤儿页面被清理，正常页面保留
|
||||
const after = await backend.listKeys();
|
||||
expect(after).not.toContain('pg_999999');
|
||||
expect(after).not.toContain('pg_999998');
|
||||
expect(await engine.count('items')).toBe(1);
|
||||
await engine.close();
|
||||
});
|
||||
|
||||
it('清理 OPFS 残留临时文件（.crswap/.tmp）', async () => {
|
||||
// 用 OPFS mock 后端验证 cleanupStaleFiles 被调用
|
||||
const { files, dir } = installOPFSMock(new Map());
|
||||
const engine = new AriaEngine({ storageBackend: 'opfs', checkpointInterval: 100000 });
|
||||
await engine.open('repair-opfs-1', 1);
|
||||
await engine.createTable(SCHEMA());
|
||||
await engine.insert('items', [{ id: 'a', val: 1, tag: 'x' }]);
|
||||
|
||||
// 制造残留
|
||||
await dir.getFileHandle('junk.crswap', { create: true });
|
||||
await dir.getFileHandle('junk2.tmp', { create: true });
|
||||
expect(Array.from(files.keys()).some((k) => k.endsWith('.crswap'))).toBe(true);
|
||||
|
||||
await (engine as any).repair();
|
||||
|
||||
const after = Array.from(files.keys());
|
||||
expect(after.some((k) => k.endsWith('.crswap'))).toBe(false);
|
||||
expect(after.some((k) => k.endsWith('.tmp'))).toBe(false);
|
||||
expect(await engine.count('items')).toBe(1);
|
||||
await engine.close();
|
||||
});
|
||||
|
||||
it('WAL 空洞 + repair → 截断清空（不再重放错位数据）', async () => {
|
||||
const dbName = uniqueDB();
|
||||
const engine = new AriaEngine({ storageBackend: 'indexeddb', checkpointInterval: 100000 });
|
||||
await engine.open(dbName, 1);
|
||||
await engine.createTable(SCHEMA());
|
||||
// 数据落盘 + checkpoint 清 WAL
|
||||
await engine.insert('items', [{ id: 'a', val: 1, tag: 'x' }]);
|
||||
await (engine as any).lsm.flush();
|
||||
await (engine as any).wal.checkpoint();
|
||||
// 新数据只进 WAL
|
||||
await engine.insert('items', [{ id: 'b', val: 2, tag: 'y' }]);
|
||||
const backend = (engine as any).backend;
|
||||
const keys = await backend.listKeys();
|
||||
const walSeg = keys.find((k: string) => k.startsWith('__wal_'));
|
||||
// 制造空洞：删掉当前分片（数据仍在内存）
|
||||
await backend.delete(walSeg);
|
||||
|
||||
await (engine as any).repair();
|
||||
|
||||
// repair 后 WAL 已清空，无空洞残留
|
||||
const after = await backend.listKeys();
|
||||
expect(after.some((k: string) => k.startsWith('__wal_'))).toBe(false);
|
||||
// 在线自愈：memtable 中的 'b'（已确认写入）随 flush 落盘 → 数据完整不丢
|
||||
const rows = await engine.find('items', { table: 'items' });
|
||||
expect(rows).toHaveLength(2);
|
||||
expect(rows.some((r) => r.id === 'a')).toBe(true);
|
||||
expect(rows.some((r) => r.id === 'b')).toBe(true);
|
||||
await engine.close();
|
||||
});
|
||||
|
||||
it('repair 幂等（连续调用无副作用）', async () => {
|
||||
const dbName = uniqueDB();
|
||||
const engine = new AriaEngine({ storageBackend: 'indexeddb', checkpointInterval: 100000 });
|
||||
await engine.open(dbName, 1);
|
||||
await engine.createTable(SCHEMA());
|
||||
await engine.insert('items', [{ id: 'a', val: 1, tag: 'x' }]);
|
||||
await (engine as any).repair();
|
||||
await (engine as any).repair();
|
||||
await (engine as any).repair();
|
||||
expect(await engine.count('items')).toBe(1);
|
||||
await engine.close();
|
||||
});
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// 随机操作压力 + 模拟崩溃
|
||||
// ===================================================================
|
||||
describe('AriaEngine — 随机操作压力 + 模拟崩溃', () => {
|
||||
it('500 随机操作（insert/update/delete）→ 模拟崩溃 → 重开验证全部已确认写入', async () => {
|
||||
const dbName = uniqueDB();
|
||||
const engine = new AriaEngine({
|
||||
storageBackend: 'indexeddb',
|
||||
memtableSizeThreshold: 8 * 1024,
|
||||
checkpointInterval: 50,
|
||||
walSyncMode: 'full',
|
||||
});
|
||||
await engine.open(dbName, 1);
|
||||
await engine.createTable(SCHEMA());
|
||||
|
||||
let seed = 12345;
|
||||
const rand = () => { seed = (seed * 1103515245 + 12345) & 0x7fffffff; return seed / 0x7fffffff; };
|
||||
|
||||
// 已确认写入集合（模拟应用层已收到成功返回）
|
||||
const confirmed = new Map<string, { val: number; tag: string }>();
|
||||
for (let i = 0; i < 500; i++) {
|
||||
const r = rand();
|
||||
const id = `k-${Math.floor(rand() * 100)}`;
|
||||
if (r < 0.6) {
|
||||
// insert/upsert（随机 id 可能碰撞 → 已存在则跳过，confirmed 保持首个值）
|
||||
const row = { id, val: Math.floor(rand() * 1000), tag: `t${Math.floor(rand() * 5)}` };
|
||||
try {
|
||||
await engine.insert('items', [row]);
|
||||
confirmed.set(id, row);
|
||||
} catch (e) {
|
||||
if ((e as { code?: string }).code !== 'DUPLICATE_KEY') throw e;
|
||||
}
|
||||
} else if (r < 0.8) {
|
||||
// update
|
||||
const upd = { val: Math.floor(rand() * 1000) };
|
||||
await engine.update('items', { table: 'items', where: { id } }, upd);
|
||||
const cur = confirmed.get(id);
|
||||
if (cur) confirmed.set(id, { ...cur, ...upd });
|
||||
} else {
|
||||
// delete
|
||||
await engine.delete('items', { table: 'items', where: { id } });
|
||||
confirmed.delete(id);
|
||||
}
|
||||
}
|
||||
|
||||
// 模拟崩溃：不 close（不 checkpoint），直接断开 backend
|
||||
await (engine as any).backend.close();
|
||||
(engine as any).opened = false;
|
||||
|
||||
// 重开：WAL 重放 + SSTable 加载
|
||||
const engine2 = new AriaEngine({ storageBackend: 'indexeddb', checkpointInterval: 50, walSyncMode: 'full' });
|
||||
await engine2.open(dbName, 1);
|
||||
const rows = await engine2.find('items', { table: 'items' });
|
||||
const byId = new Map(rows.map((r) => [r.id, r]));
|
||||
// 全部已确认写入可见
|
||||
expect(byId.size).toBe(confirmed.size);
|
||||
for (const [id, expected] of confirmed) {
|
||||
expect(byId.has(id)).toBe(true);
|
||||
expect(byId.get(id)!.val).toBe(expected.val);
|
||||
}
|
||||
await engine2.close();
|
||||
});
|
||||
|
||||
it('随机操作 + 页面化 + 模拟崩溃 → 重开验证', async () => {
|
||||
const files = installOPFSMock(new Map());
|
||||
const dbName = `rand-opfs-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
|
||||
const engine = new AriaEngine({
|
||||
storageBackend: 'opfs',
|
||||
memtableSizeThreshold: 8 * 1024,
|
||||
checkpointInterval: 50,
|
||||
walSyncMode: 'full',
|
||||
});
|
||||
await engine.open(dbName, 1);
|
||||
await engine.createTable(SCHEMA());
|
||||
|
||||
let seed = 999;
|
||||
const rand = () => { seed = (seed * 1103515245 + 12345) & 0x7fffffff; return seed / 0x7fffffff; };
|
||||
const confirmed = new Map<string, { val: number; tag: string }>();
|
||||
for (let i = 0; i < 300; i++) {
|
||||
const r = rand();
|
||||
const id = `p-${Math.floor(rand() * 80)}`;
|
||||
if (r < 0.6) {
|
||||
const row = { id, val: Math.floor(rand() * 500), tag: `tag${Math.floor(rand() * 4)}` };
|
||||
try {
|
||||
await engine.insert('items', [row]);
|
||||
confirmed.set(id, row);
|
||||
} catch (e) {
|
||||
if ((e as { code?: string }).code !== 'DUPLICATE_KEY') throw e;
|
||||
}
|
||||
} else if (r < 0.8) {
|
||||
const upd = { val: Math.floor(rand() * 500) };
|
||||
await engine.update('items', { table: 'items', where: { id } }, upd);
|
||||
const cur = confirmed.get(id);
|
||||
if (cur) confirmed.set(id, { ...cur, ...upd });
|
||||
} else {
|
||||
await engine.delete('items', { table: 'items', where: { id } });
|
||||
confirmed.delete(id);
|
||||
}
|
||||
}
|
||||
|
||||
// 模拟崩溃
|
||||
await (engine as any).backend.close();
|
||||
(engine as any).opened = false;
|
||||
|
||||
const engine2 = new AriaEngine({ storageBackend: 'opfs', checkpointInterval: 50, walSyncMode: 'full' });
|
||||
await engine2.open(dbName, 1);
|
||||
const rows = await engine2.find('items', { table: 'items' });
|
||||
const byId = new Map(rows.map((r) => [r.id, r]));
|
||||
expect(byId.size).toBe(confirmed.size);
|
||||
for (const [id, expected] of confirmed) {
|
||||
expect(byId.get(id)!.val).toBe(expected.val);
|
||||
}
|
||||
// 索引查询也验证
|
||||
const tagged = await engine2.find('items', { table: 'items', where: { tag: 'tag0' } });
|
||||
const expectedTagged = Array.from(confirmed.values()).filter((v) => v.tag === 'tag0').length;
|
||||
expect(tagged.length).toBe(expectedTagged);
|
||||
await engine2.close();
|
||||
});
|
||||
});
|
||||
+264
-129
@@ -1,129 +1,264 @@
|
||||
/**
|
||||
* AriaEngine SSTable Builder + Reader 单元测试
|
||||
*/
|
||||
import { SSTableBuilder } from '../../src/engine/aria/index/sstable_builder';
|
||||
import { SSTableReader } from '../../src/engine/aria/index/sstable';
|
||||
import type { SSTableMeta } from '../../src/engine/aria/types';
|
||||
|
||||
// ===================================================================
|
||||
// SSTable Builder + Reader
|
||||
// ===================================================================
|
||||
describe('AriaEngine — SSTable Builder + Reader', () => {
|
||||
const makeMeta = (data: Uint8Array): SSTableMeta => ({
|
||||
id: 1, level: 0, minKey: '', maxKey: '\uffff',
|
||||
blockCount: 1, totalSize: data.byteLength, bloomData: null,
|
||||
});
|
||||
|
||||
it('构建单条目 SSTable 并精确读取', () => {
|
||||
const builder = new SSTableBuilder(4096);
|
||||
builder.add('key1', { name: 'Alice', age: 30 });
|
||||
const { sstableData } = builder.build();
|
||||
|
||||
const reader = new SSTableReader(sstableData, makeMeta(sstableData));
|
||||
const result = reader.get('key1');
|
||||
expect(result).not.toBeNull();
|
||||
expect(result!.name).toBe('Alice');
|
||||
expect(result!.age).toBe(30);
|
||||
});
|
||||
|
||||
it('构建多条 SSTable 并全部读取', () => {
|
||||
const builder = new SSTableBuilder(4096);
|
||||
const items: [string, Record<string, unknown>][] = [];
|
||||
for (let i = 0; i < 100; i++) {
|
||||
const key = `user-${String(i).padStart(3, '0')}`;
|
||||
const value = { idx: i, name: `User${i}` };
|
||||
items.push([key, value]);
|
||||
builder.add(key, value);
|
||||
}
|
||||
const { sstableData } = builder.build();
|
||||
|
||||
const reader = new SSTableReader(sstableData, makeMeta(sstableData));
|
||||
for (const [key, value] of items) {
|
||||
const result = reader.get(key);
|
||||
expect(result).not.toBeNull();
|
||||
expect(result!.idx).toBe(value.idx);
|
||||
}
|
||||
});
|
||||
|
||||
it('get — 不存在的 key 返回 null', () => {
|
||||
const builder = new SSTableBuilder(4096);
|
||||
builder.add('a', { v: 1 });
|
||||
const { sstableData } = builder.build();
|
||||
|
||||
const reader = new SSTableReader(sstableData, makeMeta(sstableData));
|
||||
expect(reader.get('nonexistent')).toBeNull();
|
||||
});
|
||||
|
||||
it('rangeScan — 范围查询', () => {
|
||||
const builder = new SSTableBuilder(4096);
|
||||
for (let i = 0; i < 20; i++) {
|
||||
builder.add(`k-${String(i).padStart(2, '0')}`, { v: i });
|
||||
}
|
||||
const { sstableData } = builder.build();
|
||||
|
||||
const reader = new SSTableReader(sstableData, makeMeta(sstableData));
|
||||
const results: [string, Record<string, unknown>][] = [];
|
||||
reader.rangeScan('k-05', 'k-10', (k, v) => results.push([k, v]));
|
||||
expect(results).toHaveLength(6);
|
||||
expect(results[0][0]).toBe('k-05');
|
||||
expect(results[results.length - 1][0]).toBe('k-10');
|
||||
});
|
||||
|
||||
it('scanAll — 遍历所有条目', () => {
|
||||
const builder = new SSTableBuilder(4096);
|
||||
const count = 50;
|
||||
for (let i = 0; i < count; i++) {
|
||||
builder.add(`item-${i}`, { idx: i });
|
||||
}
|
||||
const { sstableData } = builder.build();
|
||||
|
||||
const reader = new SSTableReader(sstableData, makeMeta(sstableData));
|
||||
const items: [string, Record<string, unknown>][] = [];
|
||||
reader.scanAll((k, v) => items.push([k, v]));
|
||||
expect(items).toHaveLength(count);
|
||||
});
|
||||
|
||||
it('getIndexBlockCount 返回索引块数', () => {
|
||||
const builder = new SSTableBuilder(256); // 小 block size 触发多个 block
|
||||
for (let i = 0; i < 100; i++) {
|
||||
builder.add(`k-${i}`, { data: 'x'.repeat(50) });
|
||||
}
|
||||
const { sstableData } = builder.build();
|
||||
|
||||
const reader = new SSTableReader(sstableData, makeMeta(sstableData));
|
||||
expect(reader.getIndexBlockCount()).toBeGreaterThanOrEqual(1);
|
||||
});
|
||||
|
||||
it('边界 — 空 SSTable 不抛异常', () => {
|
||||
const builder = new SSTableBuilder(4096);
|
||||
const { sstableData } = builder.build();
|
||||
|
||||
const reader = new SSTableReader(sstableData, makeMeta(sstableData));
|
||||
expect(reader.get('any')).toBeNull();
|
||||
const results: [string, Record<string, unknown>][] = [];
|
||||
reader.scanAll((k, v) => results.push([k, v]));
|
||||
expect(results).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('带特殊字符的 key', () => {
|
||||
const builder = new SSTableBuilder(4096);
|
||||
// 必须按键排序添加（按 ASCII 排序：空格 < 短横 < 点号）
|
||||
builder.add('key with space', { v: 3 });
|
||||
builder.add('key-with-dash', { v: 1 });
|
||||
builder.add('key.with.dot', { v: 2 });
|
||||
const { sstableData } = builder.build();
|
||||
|
||||
const reader = new SSTableReader(sstableData, makeMeta(sstableData));
|
||||
expect(reader.get('key-with-dash')!.v).toBe(1);
|
||||
expect(reader.get('key.with.dot')!.v).toBe(2);
|
||||
expect(reader.get('key with space')!.v).toBe(3);
|
||||
});
|
||||
|
||||
it('getEntryCount 返回正确条目数', () => {
|
||||
const builder = new SSTableBuilder(4096);
|
||||
builder.add('a', { v: 1 });
|
||||
builder.add('b', { v: 2 });
|
||||
builder.add('c', { v: 3 });
|
||||
expect(builder.getEntryCount()).toBe(3);
|
||||
});
|
||||
});
|
||||
/**
|
||||
* AriaEngine SSTable Builder + Reader 单元测试
|
||||
*/
|
||||
import { SSTableBuilder } from '../../src/engine/aria/index/sstable_builder';
|
||||
import { SSTableReader } from '../../src/engine/aria/index/sstable';
|
||||
import type { SSTableMeta } from '../../src/engine/aria/types';
|
||||
|
||||
// ===================================================================
|
||||
// SSTable Builder + Reader
|
||||
// ===================================================================
|
||||
describe('AriaEngine — SSTable Builder + Reader', () => {
|
||||
const makeMeta = (data: Uint8Array): SSTableMeta => ({
|
||||
id: 1, level: 0, minKey: '', maxKey: '\uffff',
|
||||
blockCount: 1, totalSize: data.byteLength, bloomData: null,
|
||||
});
|
||||
|
||||
it('构建单条目 SSTable 并精确读取', () => {
|
||||
const builder = new SSTableBuilder(4096);
|
||||
builder.add('key1', { name: 'Alice', age: 30 });
|
||||
const { sstableData } = builder.build();
|
||||
|
||||
const reader = new SSTableReader(sstableData, makeMeta(sstableData));
|
||||
const result = reader.get('key1');
|
||||
expect(result).not.toBeNull();
|
||||
expect(result!.name).toBe('Alice');
|
||||
expect(result!.age).toBe(30);
|
||||
});
|
||||
|
||||
it('构建多条 SSTable 并全部读取', () => {
|
||||
const builder = new SSTableBuilder(4096);
|
||||
const items: [string, Record<string, unknown>][] = [];
|
||||
for (let i = 0; i < 100; i++) {
|
||||
const key = `user-${String(i).padStart(3, '0')}`;
|
||||
const value = { idx: i, name: `User${i}` };
|
||||
items.push([key, value]);
|
||||
builder.add(key, value);
|
||||
}
|
||||
const { sstableData } = builder.build();
|
||||
|
||||
const reader = new SSTableReader(sstableData, makeMeta(sstableData));
|
||||
for (const [key, value] of items) {
|
||||
const result = reader.get(key);
|
||||
expect(result).not.toBeNull();
|
||||
expect(result!.idx).toBe(value.idx);
|
||||
}
|
||||
});
|
||||
|
||||
it('get — 不存在的 key 返回 null', () => {
|
||||
const builder = new SSTableBuilder(4096);
|
||||
builder.add('a', { v: 1 });
|
||||
const { sstableData } = builder.build();
|
||||
|
||||
const reader = new SSTableReader(sstableData, makeMeta(sstableData));
|
||||
expect(reader.get('nonexistent')).toBeNull();
|
||||
});
|
||||
|
||||
it('rangeScan — 范围查询', () => {
|
||||
const builder = new SSTableBuilder(4096);
|
||||
for (let i = 0; i < 20; i++) {
|
||||
builder.add(`k-${String(i).padStart(2, '0')}`, { v: i });
|
||||
}
|
||||
const { sstableData } = builder.build();
|
||||
|
||||
const reader = new SSTableReader(sstableData, makeMeta(sstableData));
|
||||
const results: [string, Record<string, unknown>][] = [];
|
||||
reader.rangeScan('k-05', 'k-10', (k, v) => results.push([k, v]));
|
||||
expect(results).toHaveLength(6);
|
||||
expect(results[0][0]).toBe('k-05');
|
||||
expect(results[results.length - 1][0]).toBe('k-10');
|
||||
});
|
||||
|
||||
it('scanAll — 遍历所有条目', () => {
|
||||
const builder = new SSTableBuilder(4096);
|
||||
const count = 50;
|
||||
for (let i = 0; i < count; i++) {
|
||||
builder.add(`item-${i}`, { idx: i });
|
||||
}
|
||||
const { sstableData } = builder.build();
|
||||
|
||||
const reader = new SSTableReader(sstableData, makeMeta(sstableData));
|
||||
const items: [string, Record<string, unknown>][] = [];
|
||||
reader.scanAll((k, v) => items.push([k, v]));
|
||||
expect(items).toHaveLength(count);
|
||||
});
|
||||
|
||||
|
||||
it('边界 — 空 SSTable 不抛异常', () => {
|
||||
const builder = new SSTableBuilder(4096);
|
||||
const { sstableData } = builder.build();
|
||||
|
||||
const reader = new SSTableReader(sstableData, makeMeta(sstableData));
|
||||
expect(reader.get('any')).toBeNull();
|
||||
const results: [string, Record<string, unknown>][] = [];
|
||||
reader.scanAll((k, v) => results.push([k, v]));
|
||||
expect(results).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('带特殊字符的 key', () => {
|
||||
const builder = new SSTableBuilder(4096);
|
||||
// 必须按键排序添加（按 ASCII 排序：空格 < 短横 < 点号）
|
||||
builder.add('key with space', { v: 3 });
|
||||
builder.add('key-with-dash', { v: 1 });
|
||||
builder.add('key.with.dot', { v: 2 });
|
||||
const { sstableData } = builder.build();
|
||||
|
||||
const reader = new SSTableReader(sstableData, makeMeta(sstableData));
|
||||
expect(reader.get('key-with-dash')!.v).toBe(1);
|
||||
expect(reader.get('key.with.dot')!.v).toBe(2);
|
||||
expect(reader.get('key with space')!.v).toBe(3);
|
||||
});
|
||||
|
||||
it('getEntryCount 返回正确条目数', () => {
|
||||
const builder = new SSTableBuilder(4096);
|
||||
builder.add('a', { v: 1 });
|
||||
builder.add('b', { v: 2 });
|
||||
builder.add('c', { v: 3 });
|
||||
expect(builder.getEntryCount()).toBe(3);
|
||||
});
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// v0.4.5: 整文件 CRC-32 校验
|
||||
// ===================================================================
|
||||
describe('AriaEngine — SSTable CRC-32 校验', () => {
|
||||
const makeMeta = (data: Uint8Array): SSTableMeta => ({
|
||||
id: 1, level: 0, minKey: '', maxKey: '\uffff',
|
||||
blockCount: 1, totalSize: data.byteLength, bloomData: null,
|
||||
});
|
||||
|
||||
it('新构建的 SSTable 写入真实非零 checksum', () => {
|
||||
const builder = new SSTableBuilder(4096);
|
||||
builder.add('key1', { name: 'Alice' });
|
||||
const { sstableData } = builder.build();
|
||||
|
||||
const reader = new SSTableReader(sstableData, makeMeta(sstableData));
|
||||
// footer 最后 4 字节为真实 checksum（非 0）
|
||||
const stored = new DataView(sstableData.buffer, sstableData.byteOffset + sstableData.byteLength - 4, 4).getUint32(0, false);
|
||||
expect(stored).not.toBe(0);
|
||||
expect(reader.verifyChecksum()).toBe(true);
|
||||
});
|
||||
|
||||
it('正常文件校验通过后可正常读取', () => {
|
||||
const builder = new SSTableBuilder(4096);
|
||||
for (let i = 0; i < 50; i++) builder.add(`k-${i}`, { v: i });
|
||||
const { sstableData } = builder.build();
|
||||
|
||||
const reader = new SSTableReader(sstableData, makeMeta(sstableData));
|
||||
expect(reader.verifyChecksum()).toBe(true);
|
||||
expect(reader.get('k-30')).toEqual({ v: 30 });
|
||||
});
|
||||
|
||||
it('数据块字节篡改 → 校验失败', () => {
|
||||
const builder = new SSTableBuilder(4096);
|
||||
for (let i = 0; i < 50; i++) builder.add(`k-${i}`, { v: i, pad: 'x'.repeat(64) });
|
||||
const { sstableData } = builder.build();
|
||||
|
||||
// 篡改数据区中部一个字节（非 footer）
|
||||
const corrupted = new Uint8Array(sstableData);
|
||||
corrupted[Math.floor(corrupted.length / 2)] ^= 0xff;
|
||||
|
||||
const reader = new SSTableReader(corrupted, makeMeta(corrupted));
|
||||
// 结构仍可解析（长度一致），但 CRC 必须失败
|
||||
const stored = new DataView(corrupted.buffer, corrupted.byteOffset + corrupted.byteLength - 4, 4).getUint32(0, false);
|
||||
expect(stored).not.toBe(0);
|
||||
expect(reader.verifyChecksum()).toBe(false);
|
||||
});
|
||||
|
||||
it('索引块字节篡改 → 校验失败', () => {
|
||||
const builder = new SSTableBuilder(4096);
|
||||
for (let i = 0; i < 20; i++) builder.add(`k-${i}`, { v: i });
|
||||
const { sstableData } = builder.build();
|
||||
|
||||
// 从 footer 反推索引块位置并篡改
|
||||
const footerOffset = sstableData.byteLength - 32;
|
||||
const view = new DataView(sstableData.buffer, sstableData.byteOffset, sstableData.byteLength);
|
||||
const indexOffset = view.getUint32(footerOffset, false);
|
||||
const corrupted = new Uint8Array(sstableData);
|
||||
corrupted[indexOffset + 8] ^= 0x01;
|
||||
|
||||
const reader = new SSTableReader(corrupted, makeMeta(corrupted));
|
||||
expect(reader.verifyChecksum()).toBe(false);
|
||||
});
|
||||
|
||||
it('旧版文件（checksum=0）跳过校验，保持兼容', () => {
|
||||
const builder = new SSTableBuilder(4096);
|
||||
builder.add('legacy', { v: 1 });
|
||||
const { sstableData } = builder.build();
|
||||
|
||||
// 手工把 checksum 字段清零，模拟旧版写入产物
|
||||
const legacy = new Uint8Array(sstableData);
|
||||
new DataView(legacy.buffer).setUint32(legacy.byteLength - 4, 0, false);
|
||||
|
||||
const reader = new SSTableReader(legacy, makeMeta(legacy));
|
||||
const stored = new DataView(legacy.buffer, legacy.byteOffset + legacy.byteLength - 4, 4).getUint32(0, false);
|
||||
expect(stored).toBe(0);
|
||||
expect(reader.verifyChecksum()).toBe(true); // 跳过校验
|
||||
expect(reader.get('legacy')).toEqual({ v: 1 }); // 数据仍可读
|
||||
});
|
||||
|
||||
it('v1 旧格式文件（magic SSTB，checksum=0）校验通过且可读', () => {
|
||||
// 手工构造 v1 格式最小文件：单条记录 + 索引 + footer（magic SSTB, checksum 0）
|
||||
const encoder = new TextEncoder();
|
||||
const keyBytes = encoder.encode('old-key');
|
||||
const valBytes = encoder.encode(JSON.stringify({ v: 42 }));
|
||||
|
||||
// data block: entryCount(u32)=1 + keyLen(u16)+key + valLen(u16)+val
|
||||
const block = new ArrayBuffer(4 + 2 + keyBytes.length + 2 + valBytes.length);
|
||||
const bv = new DataView(block);
|
||||
let off = 0;
|
||||
bv.setUint32(off, 1, false); off += 4;
|
||||
bv.setUint16(off, keyBytes.length, false); off += 2;
|
||||
new Uint8Array(block).set(keyBytes, off); off += keyBytes.length;
|
||||
bv.setUint16(off, valBytes.length, false); off += 2;
|
||||
new Uint8Array(block).set(valBytes, off); off += valBytes.length;
|
||||
|
||||
// index block: entryCount(u32)=1 + keyLen(u16)+key + blockOffset(u32) + blockSize(u32)
|
||||
const blockSize = block.byteLength;
|
||||
const idxKey = encoder.encode('old-key');
|
||||
const idxBlock = new ArrayBuffer(4 + 2 + idxKey.length + 4 + 4);
|
||||
const iv = new DataView(idxBlock);
|
||||
let ioff = 0;
|
||||
iv.setUint32(ioff, 1, false); ioff += 4;
|
||||
iv.setUint16(ioff, idxKey.length, false); ioff += 2;
|
||||
new Uint8Array(idxBlock).set(idxKey, ioff); ioff += idxKey.length;
|
||||
iv.setUint32(ioff, 0, false); ioff += 4; // blockOffset = 0
|
||||
iv.setUint32(ioff, blockSize, false); ioff += 4;
|
||||
|
||||
const footerSize = 32;
|
||||
const total = block.byteLength + idxBlock.byteLength + footerSize;
|
||||
const file = new ArrayBuffer(total);
|
||||
const fv = new DataView(file);
|
||||
new Uint8Array(file).set(new Uint8Array(block), 0);
|
||||
new Uint8Array(file).set(new Uint8Array(idxBlock), block.byteLength);
|
||||
const fo = block.byteLength + idxBlock.byteLength;
|
||||
fv.setUint32(fo, block.byteLength, false); // index_offset
|
||||
fv.setUint32(fo + 4, idxBlock.byteLength, false);
|
||||
fv.setUint32(fo + 8, 0, false); // bloom_offset
|
||||
fv.setUint32(fo + 12, 0, false); // bloom_size
|
||||
fv.setUint32(fo + 16, 0, false); // bloom_hash_count
|
||||
fv.setUint32(fo + 20, 1, false); // entry_count
|
||||
fv.setUint32(fo + 24, 0x53535442, false); // magic "SSTB" (v1)
|
||||
fv.setUint32(fo + 28, 0, false); // checksum = 0（旧版无校验）
|
||||
|
||||
const data = new Uint8Array(file);
|
||||
const reader = new SSTableReader(data, makeMeta(data));
|
||||
const stored = new DataView(data.buffer, data.byteOffset + data.byteLength - 4, 4).getUint32(0, false);
|
||||
expect(stored).toBe(0);
|
||||
expect(reader.verifyChecksum()).toBe(true);
|
||||
expect(reader.get('old-key')).toEqual({ v: 42 });
|
||||
});
|
||||
|
||||
it('footer checksum 字段自身篡改 → 校验失败', () => {
|
||||
const builder = new SSTableBuilder(4096);
|
||||
builder.add('a', { v: 1 });
|
||||
const { sstableData } = builder.build();
|
||||
|
||||
const tampered = new Uint8Array(sstableData);
|
||||
const view = new DataView(tampered.buffer);
|
||||
view.setUint32(tampered.byteLength - 4, view.getUint32(tampered.byteLength - 4, false) ^ 0x000000ff, false);
|
||||
|
||||
const reader = new SSTableReader(tampered, makeMeta(tampered));
|
||||
expect(reader.verifyChecksum()).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -0,0 +1,218 @@
|
||||
/**
|
||||
* AriaEngine WAL — CRC-32 校验升级测试
|
||||
*
|
||||
* 覆盖：
|
||||
* 1. 新算法记录往返（append → recover）
|
||||
* 2. 篡改记录字节 → CRC 不匹配跳过
|
||||
* 3. 旧版弱校验记录兼容（双算法探测）
|
||||
* 4. appendBatch 组提交记录往返
|
||||
* 5. 损坏记录跳过不影响后续完整记录
|
||||
*/
|
||||
import { WAL } from '../../src/engine/aria/wal/log';
|
||||
import { WALRecordType } from '../../src/engine/aria/types';
|
||||
|
||||
// ===================================================================
|
||||
// WAL 内存 Store（模拟 IStorageBackend 单记录语义）
|
||||
// ===================================================================
|
||||
class MemoryWALStore {
|
||||
chunks: Uint8Array[] = [];
|
||||
truncated = false;
|
||||
|
||||
async append(data: Uint8Array): Promise<void> {
|
||||
this.chunks.push(data);
|
||||
}
|
||||
|
||||
async readAll(): Promise<Uint8Array> {
|
||||
const total = this.chunks.reduce((s, c) => s + c.byteLength, 0);
|
||||
const combined = new Uint8Array(total);
|
||||
let off = 0;
|
||||
for (const c of this.chunks) { combined.set(c, off); off += c.byteLength; }
|
||||
return combined;
|
||||
}
|
||||
|
||||
async truncate(): Promise<void> {
|
||||
this.chunks = [];
|
||||
this.truncated = true;
|
||||
}
|
||||
|
||||
async exists(): Promise<boolean> {
|
||||
return this.chunks.length > 0;
|
||||
}
|
||||
}
|
||||
|
||||
function makeRecord(over: Partial<import('../../src/engine/aria/types').WALRecord> = {}) {
|
||||
return {
|
||||
type: WALRecordType.INSERT,
|
||||
txnId: 0,
|
||||
tableName: 'users',
|
||||
key: 'u-1',
|
||||
data: { id: 'u-1', name: 'Alice' },
|
||||
...over,
|
||||
};
|
||||
}
|
||||
|
||||
describe('AriaEngine — WAL CRC-32 校验', () => {
|
||||
it('新算法记录 append → recover 往返完整', async () => {
|
||||
const store = new MemoryWALStore();
|
||||
const wal = new WAL(store as never, true, 'full');
|
||||
|
||||
await wal.append(makeRecord({ key: 'u-1' }));
|
||||
await wal.append(makeRecord({ key: 'u-2', data: { id: 'u-2', name: 'Bob' } }));
|
||||
|
||||
const records: import('../../src/engine/aria/types').WALRecord[] = [];
|
||||
await wal.recover((r) => records.push(r));
|
||||
expect(records).toHaveLength(2);
|
||||
expect(records[0].key).toBe('u-1');
|
||||
expect(records[1].data).toEqual({ id: 'u-2', name: 'Bob' });
|
||||
});
|
||||
|
||||
it('appendBatch 组提交记录往返完整', async () => {
|
||||
const store = new MemoryWALStore();
|
||||
const wal = new WAL(store as never, true, 'full');
|
||||
|
||||
await wal.appendBatch([
|
||||
makeRecord({ key: 'a' }),
|
||||
makeRecord({ key: 'b' }),
|
||||
makeRecord({ key: 'c' }),
|
||||
]);
|
||||
|
||||
const records: import('../../src/engine/aria/types').WALRecord[] = [];
|
||||
await wal.recover((r) => records.push(r));
|
||||
expect(records.map((r) => r.key)).toEqual(['a', 'b', 'c']);
|
||||
expect(records.map((r) => r.lsn)).toEqual([1, 2, 3]);
|
||||
});
|
||||
|
||||
it('篡改记录数据 → CRC 不匹配跳过', async () => {
|
||||
const store = new MemoryWALStore();
|
||||
const wal = new WAL(store as never, true, 'full');
|
||||
|
||||
await wal.append(makeRecord({ key: 'good-1' }));
|
||||
await wal.append(makeRecord({ key: 'evil' }));
|
||||
await wal.append(makeRecord({ key: 'good-2' }));
|
||||
|
||||
// 篡改第二条记录的 data 字节（LSN=2 的记录）
|
||||
const raw = await store.readAll();
|
||||
const view = new DataView(raw.buffer, raw.byteOffset, raw.byteLength);
|
||||
// 定位第二条记录起始：按记录格式顺序扫描直到 LSN=2
|
||||
// [lsn:4][type:1][txnId:4][tblLen:2][table][keyLen:2][key][jsonLen:4][json][crc:4]
|
||||
let offset = 0;
|
||||
while (offset + 4 <= raw.byteLength && view.getUint32(offset, false) !== 2) {
|
||||
const tblLen = view.getUint16(offset + 9, false);
|
||||
const keyLenOff = offset + 11 + tblLen;
|
||||
const keyLen = view.getUint16(keyLenOff, false);
|
||||
const jsonLenOff = keyLenOff + 2 + keyLen;
|
||||
const jsonLen = view.getUint32(jsonLenOff, false);
|
||||
offset += 4 + 1 + 4 + 2 + tblLen + 2 + keyLen + 4 + jsonLen + 4;
|
||||
}
|
||||
expect(view.getUint32(offset, false)).toBe(2);
|
||||
// 篡改 data 区（json 起始处第 4 字节）
|
||||
const tblLen2 = view.getUint16(offset + 9, false);
|
||||
const jsonStart = offset + 4 + 1 + 4 + 2 + tblLen2 + 2 + view.getUint16(offset + 11 + tblLen2, false) + 4;
|
||||
raw[jsonStart + 4] ^= 0x01;
|
||||
// 写回 store（readAll 返回的是合并副本）
|
||||
store.chunks = [raw];
|
||||
|
||||
// 恢复：坏记录被跳过，前后好记录保留
|
||||
const records: import('../../src/engine/aria/types').WALRecord[] = [];
|
||||
await wal.recover((r) => records.push(r));
|
||||
expect(records.map((r) => r.key)).toEqual(['good-1', 'good-2']);
|
||||
});
|
||||
|
||||
it('旧版弱校验记录兼容（双算法探测）', async () => {
|
||||
const store = new MemoryWALStore();
|
||||
const wal = new WAL(store as never, true, 'full');
|
||||
|
||||
// 手工构造一条"旧算法"记录：与 encodeRecord 布局一致但 CRC 用旧算法计算
|
||||
const record = {
|
||||
lsn: 1,
|
||||
type: WALRecordType.INSERT as number,
|
||||
txnId: 0,
|
||||
tableName: 'legacy',
|
||||
key: 'old',
|
||||
data: { id: 'old', v: 1 },
|
||||
};
|
||||
const encoder = new TextEncoder();
|
||||
const tblB = encoder.encode(record.tableName);
|
||||
const keyB = encoder.encode(record.key);
|
||||
const jsonB = encoder.encode(JSON.stringify(record.data));
|
||||
const size = 4 + 1 + 4 + 2 + tblB.length + 2 + keyB.length + 4 + jsonB.length + 4;
|
||||
const buf = new ArrayBuffer(size);
|
||||
const v = new DataView(buf);
|
||||
let o = 0;
|
||||
v.setUint32(o, record.lsn, false); o += 4;
|
||||
v.setUint8(o, record.type); o += 1;
|
||||
v.setUint32(o, record.txnId, false); o += 4;
|
||||
v.setUint16(o, tblB.length, false); o += 2;
|
||||
new Uint8Array(buf).set(tblB, o); o += tblB.length;
|
||||
v.setUint16(o, keyB.length, false); o += 2;
|
||||
new Uint8Array(buf).set(keyB, o); o += keyB.length;
|
||||
v.setUint32(o, jsonB.length, false); o += 4;
|
||||
new Uint8Array(buf).set(jsonB, o); o += jsonB.length;
|
||||
// 旧算法 CRC
|
||||
let crc = 0;
|
||||
const u8 = new Uint8Array(buf, 0, o);
|
||||
for (let i = 0; i < u8.length; i++) crc = ((crc << 5) - crc + u8[i]) | 0;
|
||||
v.setUint32(o, crc >>> 0, false);
|
||||
|
||||
store.chunks.push(new Uint8Array(buf));
|
||||
|
||||
const records: import('../../src/engine/aria/types').WALRecord[] = [];
|
||||
await wal.recover((r) => records.push(r));
|
||||
expect(records).toHaveLength(1);
|
||||
expect(records[0].tableName).toBe('legacy');
|
||||
expect(records[0].data).toEqual({ id: 'old', v: 1 });
|
||||
});
|
||||
|
||||
it('旧算法记录 + 新算法记录混合 → 全部正确恢复', async () => {
|
||||
const store = new MemoryWALStore();
|
||||
const wal = new WAL(store as never, true, 'full');
|
||||
|
||||
// 先放一条旧算法记录
|
||||
const record = {
|
||||
lsn: 1,
|
||||
type: WALRecordType.DELETE as number,
|
||||
txnId: 0,
|
||||
tableName: 't',
|
||||
key: 'old-key',
|
||||
data: undefined as Record<string, unknown> | undefined,
|
||||
};
|
||||
const encoder = new TextEncoder();
|
||||
const tblB = encoder.encode(record.tableName);
|
||||
const keyB = encoder.encode(record.key);
|
||||
const size = 4 + 1 + 4 + 2 + tblB.length + 2 + keyB.length + 4 + 4;
|
||||
const buf = new ArrayBuffer(size);
|
||||
const v = new DataView(buf);
|
||||
let o = 0;
|
||||
v.setUint32(o, record.lsn, false); o += 4;
|
||||
v.setUint8(o, record.type); o += 1;
|
||||
v.setUint32(o, record.txnId, false); o += 4;
|
||||
v.setUint16(o, tblB.length, false); o += 2;
|
||||
new Uint8Array(buf).set(tblB, o); o += tblB.length;
|
||||
v.setUint16(o, keyB.length, false); o += 2;
|
||||
new Uint8Array(buf).set(keyB, o); o += keyB.length;
|
||||
v.setUint32(o, 0, false); o += 4; // jsonLen=0
|
||||
let crc = 0;
|
||||
const u8 = new Uint8Array(buf, 0, o);
|
||||
for (let i = 0; i < u8.length; i++) crc = ((crc << 5) - crc + u8[i]) | 0;
|
||||
v.setUint32(o, crc >>> 0, false);
|
||||
store.chunks.push(new Uint8Array(buf));
|
||||
|
||||
// 再追加一条新算法记录（LSN=2）
|
||||
await wal.append(makeRecord({ key: 'new-key', lsn: 2 } as never));
|
||||
|
||||
const records: import('../../src/engine/aria/types').WALRecord[] = [];
|
||||
await wal.recover((r) => records.push(r));
|
||||
expect(records.map((r) => r.key)).toEqual(['old-key', 'new-key']);
|
||||
expect(records[0].type).toBe(WALRecordType.DELETE);
|
||||
});
|
||||
|
||||
it('checkpoint 截断后 exists 返回 false', async () => {
|
||||
const store = new MemoryWALStore();
|
||||
const wal = new WAL(store as never, true, 'full');
|
||||
await wal.append(makeRecord({ key: 'x' }));
|
||||
expect(await store.exists()).toBe(true);
|
||||
await wal.checkpoint();
|
||||
expect(store.truncated).toBe(true);
|
||||
expect(await store.exists()).toBe(false);
|
||||
});
|
||||
});
|
||||
+225
-289
@@ -1,289 +1,225 @@
|
||||
/**
|
||||
* AriaEngine WAL + MVCC 单元测试
|
||||
*/
|
||||
import { WAL, type WALStore } from '../../src/engine/aria/wal/log';
|
||||
import { WALRecordType, type WALRecord } from '../../src/engine/aria/types';
|
||||
import { CheckpointManager, type Flushable } from '../../src/engine/aria/wal/checkpoint';
|
||||
import { MVCCManager } from '../../src/engine/aria/transaction/mvcc';
|
||||
|
||||
// ===================================================================
|
||||
// WAL 存储 Mock
|
||||
// ===================================================================
|
||||
class MockWALStore implements WALStore {
|
||||
chunks: Uint8Array[] = [];
|
||||
async append(data: Uint8Array) { this.chunks.push(data); }
|
||||
async readAll(): Promise<Uint8Array> {
|
||||
const total = this.chunks.reduce((s, c) => s + c.byteLength, 0);
|
||||
const combined = new Uint8Array(total);
|
||||
let off = 0;
|
||||
for (const c of this.chunks) { combined.set(c, off); off += c.byteLength; }
|
||||
return combined;
|
||||
}
|
||||
async truncate() { this.chunks = []; }
|
||||
async exists() { return this.chunks.length > 0; }
|
||||
}
|
||||
|
||||
// ===================================================================
|
||||
// WAL 测试
|
||||
// ===================================================================
|
||||
describe('AriaEngine — WAL', () => {
|
||||
it('append 记录后可恢复', async () => {
|
||||
const store = new MockWALStore();
|
||||
const wal = new WAL(store, true, 'full');
|
||||
|
||||
wal.append({ type: WALRecordType.INSERT, txnId: 1, tableName: 'users', key: '1', data: { name: 'Alice' } });
|
||||
wal.append({ type: WALRecordType.INSERT, txnId: 1, tableName: 'users', key: '2', data: { name: 'Bob' } });
|
||||
|
||||
const records: WALRecord[] = [];
|
||||
await wal.recover((r) => records.push(r));
|
||||
expect(records).toHaveLength(2);
|
||||
expect(records[0].tableName).toBe('users');
|
||||
expect(records[0].key).toBe('1');
|
||||
});
|
||||
|
||||
it('batch 模式缓冲后 flush', async () => {
|
||||
const store = new MockWALStore();
|
||||
const wal = new WAL(store, true, 'batch');
|
||||
|
||||
wal.append({ type: WALRecordType.UPDATE, txnId: 2, tableName: 'items', key: 'a', data: { v: 1 } });
|
||||
wal.append({ type: WALRecordType.DELETE, txnId: 2, tableName: 'items', key: 'b' });
|
||||
|
||||
// 未 flush 前无法恢复
|
||||
let records: WALRecord[] = [];
|
||||
await wal.recover((r) => records.push(r));
|
||||
expect(records).toHaveLength(0);
|
||||
|
||||
await wal.flush();
|
||||
records = [];
|
||||
await wal.recover((r) => records.push(r));
|
||||
expect(records).toHaveLength(2);
|
||||
});
|
||||
|
||||
it('none 模式不记录', async () => {
|
||||
const store = new MockWALStore();
|
||||
const wal = new WAL(store, false, 'none');
|
||||
wal.append({ type: WALRecordType.INSERT, txnId: 3, tableName: 'x', key: 'y', data: {} });
|
||||
expect(store.chunks).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('checkpoint 清空 WAL', async () => {
|
||||
const store = new MockWALStore();
|
||||
const wal = new WAL(store, true, 'full');
|
||||
|
||||
wal.append({ type: WALRecordType.CREATE_TABLE, txnId: 0, tableName: 't', key: '' });
|
||||
expect(await store.exists()).toBe(true);
|
||||
|
||||
await wal.checkpoint();
|
||||
expect(await store.exists()).toBe(false);
|
||||
});
|
||||
|
||||
it('getLSN 跟踪序列号', () => {
|
||||
const store = new MockWALStore();
|
||||
const wal = new WAL(store, true, 'full');
|
||||
expect(wal.getLSN()).toBe(0);
|
||||
wal.append({ type: WALRecordType.BEGIN, txnId: 10, tableName: '', key: '' });
|
||||
expect(wal.getLSN()).toBe(1);
|
||||
wal.append({ type: WALRecordType.COMMIT, txnId: 10, tableName: '', key: '' });
|
||||
expect(wal.getLSN()).toBe(2);
|
||||
});
|
||||
|
||||
it('isEnabled 反映配置', () => {
|
||||
expect(new WAL(new MockWALStore(), true).isEnabled()).toBe(true);
|
||||
expect(new WAL(new MockWALStore(), false).isEnabled()).toBe(false);
|
||||
});
|
||||
|
||||
it('多种记录类型编解码', async () => {
|
||||
const store = new MockWALStore();
|
||||
const wal = new WAL(store, true, 'full');
|
||||
|
||||
wal.append({ type: WALRecordType.BEGIN, txnId: 100, tableName: '', key: '' });
|
||||
wal.append({ type: WALRecordType.INSERT, txnId: 100, tableName: 'users', key: '1', data: { x: 'hello' } });
|
||||
wal.append({ type: WALRecordType.UPDATE, txnId: 100, tableName: 'users', key: '1', data: { x: 'world' } });
|
||||
wal.append({ type: WALRecordType.COMMIT, txnId: 100, tableName: '', key: '' });
|
||||
|
||||
const records: WALRecord[] = [];
|
||||
await wal.recover((r) => records.push(r));
|
||||
expect(records).toHaveLength(4);
|
||||
expect(records[0].type).toBe(WALRecordType.BEGIN);
|
||||
expect(records[1].type).toBe(WALRecordType.INSERT);
|
||||
expect(records[2].type).toBe(WALRecordType.UPDATE);
|
||||
expect(records[3].type).toBe(WALRecordType.COMMIT);
|
||||
});
|
||||
|
||||
it('getBufferedCount 返回缓冲数', () => {
|
||||
const wal = new WAL(new MockWALStore(), true, 'batch');
|
||||
expect(wal.getBufferedCount()).toBe(0);
|
||||
wal.append({ type: WALRecordType.INSERT, txnId: 0, tableName: 't', key: 'k' });
|
||||
expect(wal.getBufferedCount()).toBe(1);
|
||||
});
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// Checkpoint 测试（使用安全 Mock，避免 null 引用导致 CI 卡死）
|
||||
// ===================================================================
|
||||
describe('AriaEngine — CheckpointManager', () => {
|
||||
class MockFlushable implements Flushable { flushed = false; async flushAll() { this.flushed = true; } }
|
||||
class MockLSM { flushed = false; async flush() { this.flushed = true; } }
|
||||
class MockWAL { checkpointed = false; async checkpoint() { this.checkpointed = true; } async flush() {} }
|
||||
|
||||
it('tick 未达间隔不触发 checkpoint', async () => {
|
||||
const lsm = new MockLSM();
|
||||
const wal = new MockWAL();
|
||||
const flushable = new MockFlushable();
|
||||
const cm = new CheckpointManager(lsm as any, wal as any, flushable, 100);
|
||||
await cm.tick();
|
||||
await cm.tick();
|
||||
expect(cm.getOpCount()).toBe(2);
|
||||
expect(flushable.flushed).toBe(false);
|
||||
expect(lsm.flushed).toBe(false);
|
||||
});
|
||||
|
||||
it('setInterval 修改间隔后 tick 触发 checkpoint', async () => {
|
||||
const lsm = new MockLSM();
|
||||
const wal = new MockWAL();
|
||||
const cm = new CheckpointManager(lsm as any, wal as any, null, 1000);
|
||||
cm.setInterval(2);
|
||||
await cm.tick();
|
||||
await cm.tick();
|
||||
expect(cm.getOpCount()).toBe(0); // reset after checkpoint
|
||||
expect(lsm.flushed).toBe(true);
|
||||
expect(wal.checkpointed).toBe(true);
|
||||
});
|
||||
|
||||
it('forceCheckpoint 强制触发', async () => {
|
||||
const lsm = new MockLSM();
|
||||
const wal = new MockWAL();
|
||||
const cm = new CheckpointManager(lsm as any, wal as any, null, 100);
|
||||
await cm.forceCheckpoint();
|
||||
expect(cm.getOpCount()).toBe(0);
|
||||
expect(lsm.flushed).toBe(true);
|
||||
expect(wal.checkpointed).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// MVCC 测试
|
||||
// ===================================================================
|
||||
describe('AriaEngine — MVCC', () => {
|
||||
let mvcc: MVCCManager;
|
||||
|
||||
beforeEach(() => { mvcc = new MVCCManager(); });
|
||||
|
||||
it('beginTransaction 分配唯一 ID', () => {
|
||||
const id1 = mvcc.beginTransaction();
|
||||
const id2 = mvcc.beginTransaction();
|
||||
expect(id1).not.toBe(id2);
|
||||
expect(mvcc.isActive(id1)).toBe(true);
|
||||
expect(mvcc.isActive(id2)).toBe(true);
|
||||
});
|
||||
|
||||
it('commit 后 isActive 返回 false', () => {
|
||||
const txnId = mvcc.beginTransaction();
|
||||
mvcc.commitTransaction(txnId);
|
||||
expect(mvcc.isActive(txnId)).toBe(false);
|
||||
});
|
||||
|
||||
it('rollback 后 isActive 返回 false', () => {
|
||||
const txnId = mvcc.beginTransaction();
|
||||
mvcc.rollbackTransaction(txnId);
|
||||
expect(mvcc.isActive(txnId)).toBe(false);
|
||||
});
|
||||
|
||||
it('writeVersion + readVersion 往返', () => {
|
||||
const txnId = mvcc.beginTransaction();
|
||||
mvcc.writeVersion('users', '1', { name: 'Alice', age: 30 }, txnId);
|
||||
const val = mvcc.readVersion('users', '1', txnId);
|
||||
expect(val).not.toBeNull();
|
||||
expect(val!.name).toBe('Alice');
|
||||
});
|
||||
|
||||
it('未提交版本对其他事务不可见', () => {
|
||||
const txn1 = mvcc.beginTransaction();
|
||||
mvcc.writeVersion('users', '1', { name: 'Alice' }, txn1);
|
||||
|
||||
const txn2 = mvcc.beginTransaction();
|
||||
const val = mvcc.readVersion('users', '1', txn2);
|
||||
expect(val).toBeNull(); // txn1's write not yet committed
|
||||
});
|
||||
|
||||
it('commit 后新事务可见', () => {
|
||||
const txn1 = mvcc.beginTransaction();
|
||||
mvcc.writeVersion('users', '1', { name: 'Alice' }, txn1);
|
||||
mvcc.commitTransaction(txn1);
|
||||
|
||||
const txn2 = mvcc.beginTransaction();
|
||||
const val = mvcc.readVersion('users', '1', txn2);
|
||||
expect(val).not.toBeNull();
|
||||
expect(val!.name).toBe('Alice');
|
||||
});
|
||||
|
||||
it('rollback 移除写入的版本', () => {
|
||||
const txnId = mvcc.beginTransaction();
|
||||
mvcc.writeVersion('users', '1', { name: 'Temp' }, txnId);
|
||||
mvcc.rollbackTransaction(txnId);
|
||||
|
||||
const txn2 = mvcc.beginTransaction();
|
||||
expect(mvcc.readVersion('users', '1', txn2)).toBeNull();
|
||||
});
|
||||
|
||||
it('deleteVersion 创建墓碑', () => {
|
||||
const txnId = mvcc.beginTransaction();
|
||||
mvcc.writeVersion('users', '1', { name: 'Alice' }, txnId);
|
||||
mvcc.commitTransaction(txnId);
|
||||
// delete
|
||||
const txn2 = mvcc.beginTransaction();
|
||||
mvcc.deleteVersion('users', '1', txn2);
|
||||
mvcc.commitTransaction(txn2);
|
||||
// 删除后读取
|
||||
const txn3 = mvcc.beginTransaction();
|
||||
const val = mvcc.readVersion('users', '1', txn3);
|
||||
expect(val).not.toBeNull();
|
||||
expect((val! as any).__mvcc_tombstone).toBe(true);
|
||||
});
|
||||
|
||||
it('getLatestCommittedVersions 返回最新已提交', () => {
|
||||
const txnId = mvcc.beginTransaction();
|
||||
mvcc.writeVersion('users', '1', { name: 'Alice' }, txnId);
|
||||
mvcc.writeVersion('users', '2', { name: 'Bob' }, txnId);
|
||||
mvcc.commitTransaction(txnId);
|
||||
|
||||
const result = mvcc.getLatestCommittedVersions('users');
|
||||
expect(result['1'].name).toBe('Alice');
|
||||
expect(result['2'].name).toBe('Bob');
|
||||
});
|
||||
|
||||
it('clearTable 清理指定表', () => {
|
||||
const txnId = mvcc.beginTransaction();
|
||||
mvcc.writeVersion('users', '1', { name: 'A' }, txnId);
|
||||
mvcc.writeVersion('users', '2', { name: 'B' }, txnId);
|
||||
mvcc.writeVersion('orders', 'o1', { amt: 100 }, txnId);
|
||||
mvcc.commitTransaction(txnId);
|
||||
|
||||
mvcc.clearTable('users');
|
||||
const txn2 = mvcc.beginTransaction();
|
||||
expect(mvcc.readVersion('users', '1', txn2)).toBeNull();
|
||||
expect(mvcc.readVersion('users', '2', txn2)).toBeNull();
|
||||
expect(mvcc.readVersion('orders', 'o1', txn2)).not.toBeNull();
|
||||
});
|
||||
|
||||
it('getActiveTxnCount 返回活跃事务数', () => {
|
||||
expect(mvcc.getActiveTxnCount()).toBe(0);
|
||||
mvcc.beginTransaction();
|
||||
mvcc.beginTransaction();
|
||||
expect(mvcc.getActiveTxnCount()).toBe(2);
|
||||
});
|
||||
|
||||
it('gc 清理过旧版本', () => {
|
||||
// 创建很多版本后 gc
|
||||
for (let i = 0; i < 200; i++) {
|
||||
const txnId = mvcc.beginTransaction();
|
||||
mvcc.writeVersion('users', '1', { ver: i }, txnId);
|
||||
mvcc.commitTransaction(txnId);
|
||||
}
|
||||
mvcc.gc(100);
|
||||
// gc 后应可继续操作
|
||||
const txnId = mvcc.beginTransaction();
|
||||
const val = mvcc.readVersion('users', '1', txnId);
|
||||
expect(val).not.toBeNull();
|
||||
});
|
||||
});
|
||||
/**
|
||||
* AriaEngine WAL + MVCC 单元测试
|
||||
*/
|
||||
import { WAL, type WALStore } from '../../src/engine/aria/wal/log';
|
||||
import { WALRecordType, type WALRecord } from '../../src/engine/aria/types';
|
||||
import { CheckpointManager, type Flushable } from '../../src/engine/aria/wal/checkpoint';
|
||||
import { MVCCManager } from '../../src/engine/aria/transaction/mvcc';
|
||||
|
||||
// ===================================================================
|
||||
// WAL 存储 Mock
|
||||
// ===================================================================
|
||||
class MockWALStore implements WALStore {
|
||||
chunks: Uint8Array[] = [];
|
||||
async append(data: Uint8Array) { this.chunks.push(data); }
|
||||
async readAll(): Promise<Uint8Array> {
|
||||
const total = this.chunks.reduce((s, c) => s + c.byteLength, 0);
|
||||
const combined = new Uint8Array(total);
|
||||
let off = 0;
|
||||
for (const c of this.chunks) { combined.set(c, off); off += c.byteLength; }
|
||||
return combined;
|
||||
}
|
||||
async truncate() { this.chunks = []; }
|
||||
async exists() { return this.chunks.length > 0; }
|
||||
}
|
||||
|
||||
// ===================================================================
|
||||
// WAL 测试
|
||||
// ===================================================================
|
||||
describe('AriaEngine — WAL', () => {
|
||||
it('append 记录后可恢复', async () => {
|
||||
const store = new MockWALStore();
|
||||
const wal = new WAL(store, true, 'full');
|
||||
|
||||
wal.append({ type: WALRecordType.INSERT, txnId: 1, tableName: 'users', key: '1', data: { name: 'Alice' } });
|
||||
wal.append({ type: WALRecordType.INSERT, txnId: 1, tableName: 'users', key: '2', data: { name: 'Bob' } });
|
||||
|
||||
const records: WALRecord[] = [];
|
||||
await wal.recover((r) => records.push(r));
|
||||
expect(records).toHaveLength(2);
|
||||
expect(records[0].tableName).toBe('users');
|
||||
expect(records[0].key).toBe('1');
|
||||
});
|
||||
|
||||
it('batch 模式缓冲后 flush', async () => {
|
||||
const store = new MockWALStore();
|
||||
const wal = new WAL(store, true, 'batch');
|
||||
|
||||
wal.append({ type: WALRecordType.UPDATE, txnId: 2, tableName: 'items', key: 'a', data: { v: 1 } });
|
||||
wal.append({ type: WALRecordType.DELETE, txnId: 2, tableName: 'items', key: 'b' });
|
||||
|
||||
// 未 flush 前无法恢复
|
||||
let records: WALRecord[] = [];
|
||||
await wal.recover((r) => records.push(r));
|
||||
expect(records).toHaveLength(0);
|
||||
|
||||
await wal.flush();
|
||||
records = [];
|
||||
await wal.recover((r) => records.push(r));
|
||||
expect(records).toHaveLength(2);
|
||||
});
|
||||
|
||||
it('none 模式不记录', async () => {
|
||||
const store = new MockWALStore();
|
||||
const wal = new WAL(store, false, 'none');
|
||||
wal.append({ type: WALRecordType.INSERT, txnId: 3, tableName: 'x', key: 'y', data: {} });
|
||||
expect(store.chunks).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('checkpoint 清空 WAL', async () => {
|
||||
const store = new MockWALStore();
|
||||
const wal = new WAL(store, true, 'full');
|
||||
|
||||
wal.append({ type: WALRecordType.CREATE_TABLE, txnId: 0, tableName: 't', key: '' });
|
||||
expect(await store.exists()).toBe(true);
|
||||
|
||||
await wal.checkpoint();
|
||||
expect(await store.exists()).toBe(false);
|
||||
});
|
||||
|
||||
it('多种记录类型编解码', async () => {
|
||||
const store = new MockWALStore();
|
||||
const wal = new WAL(store, true, 'full');
|
||||
|
||||
wal.append({ type: WALRecordType.BEGIN, txnId: 100, tableName: '', key: '' });
|
||||
wal.append({ type: WALRecordType.INSERT, txnId: 100, tableName: 'users', key: '1', data: { x: 'hello' } });
|
||||
wal.append({ type: WALRecordType.UPDATE, txnId: 100, tableName: 'users', key: '1', data: { x: 'world' } });
|
||||
wal.append({ type: WALRecordType.COMMIT, txnId: 100, tableName: '', key: '' });
|
||||
|
||||
const records: WALRecord[] = [];
|
||||
await wal.recover((r) => records.push(r));
|
||||
expect(records).toHaveLength(4);
|
||||
expect(records[0].type).toBe(WALRecordType.BEGIN);
|
||||
expect(records[1].type).toBe(WALRecordType.INSERT);
|
||||
expect(records[2].type).toBe(WALRecordType.UPDATE);
|
||||
expect(records[3].type).toBe(WALRecordType.COMMIT);
|
||||
});
|
||||
|
||||
it('getBufferedCount 返回缓冲数', () => {
|
||||
const wal = new WAL(new MockWALStore(), true, 'batch');
|
||||
expect(wal.getBufferedCount()).toBe(0);
|
||||
wal.append({ type: WALRecordType.INSERT, txnId: 0, tableName: 't', key: 'k' });
|
||||
expect(wal.getBufferedCount()).toBe(1);
|
||||
});
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// Checkpoint 测试（使用安全 Mock，避免 null 引用导致 CI 卡死）
|
||||
// ===================================================================
|
||||
describe('AriaEngine — CheckpointManager', () => {
|
||||
class MockFlushable implements Flushable { flushed = false; async flushAll() { this.flushed = true; } }
|
||||
class MockLSM { flushed = false; async flush() { this.flushed = true; } }
|
||||
class MockWAL { checkpointed = false; async checkpoint() { this.checkpointed = true; } async flush() {} }
|
||||
|
||||
it('tick 未达间隔不触发 checkpoint', async () => {
|
||||
const lsm = new MockLSM();
|
||||
const wal = new MockWAL();
|
||||
const flushable = new MockFlushable();
|
||||
const cm = new CheckpointManager(lsm as any, wal as any, flushable, 100);
|
||||
await cm.tick();
|
||||
await cm.tick();
|
||||
expect(flushable.flushed).toBe(false);
|
||||
expect(lsm.flushed).toBe(false);
|
||||
});
|
||||
|
||||
it('tick 达到间隔触发 checkpoint', async () => {
|
||||
const lsm = new MockLSM();
|
||||
const wal = new MockWAL();
|
||||
const cm = new CheckpointManager(lsm as any, wal as any, null, 2);
|
||||
await cm.tick();
|
||||
expect(lsm.flushed).toBe(false);
|
||||
await cm.tick();
|
||||
expect(lsm.flushed).toBe(true);
|
||||
expect(wal.checkpointed).toBe(true);
|
||||
});
|
||||
|
||||
it('checkpoint 直接触发', async () => {
|
||||
const lsm = new MockLSM();
|
||||
const wal = new MockWAL();
|
||||
const cm = new CheckpointManager(lsm as any, wal as any, null, 100);
|
||||
await cm.checkpoint();
|
||||
expect(lsm.flushed).toBe(true);
|
||||
expect(wal.checkpointed).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// MVCC 测试
|
||||
// ===================================================================
|
||||
describe('AriaEngine — MVCC', () => {
|
||||
let mvcc: MVCCManager;
|
||||
|
||||
beforeEach(() => { mvcc = new MVCCManager(); });
|
||||
|
||||
it('beginTransaction 分配唯一 ID', () => {
|
||||
const id1 = mvcc.beginTransaction();
|
||||
const id2 = mvcc.beginTransaction();
|
||||
expect(id1).not.toBe(id2);
|
||||
});
|
||||
|
||||
it('commit 标记版本为已提交并清理事务登记', () => {
|
||||
const txnId = mvcc.beginTransaction();
|
||||
mvcc.writeVersion('users', '1', { name: 'Alice' }, txnId);
|
||||
mvcc.commitTransaction(txnId);
|
||||
const versions = (mvcc as unknown as { versionStore: Map<string, { committed: boolean }[]> }).versionStore.get('users.1');
|
||||
expect(versions).toHaveLength(1);
|
||||
expect(versions![0].committed).toBe(true);
|
||||
});
|
||||
|
||||
it('rollback 移除写入的版本', () => {
|
||||
const txnId = mvcc.beginTransaction();
|
||||
mvcc.writeVersion('users', '1', { name: 'Temp' }, txnId);
|
||||
mvcc.rollbackTransaction(txnId);
|
||||
const store = (mvcc as unknown as { versionStore: Map<string, unknown> }).versionStore;
|
||||
expect(store.has('users.1')).toBe(false);
|
||||
});
|
||||
|
||||
it('writeVersion 记录版本链（undo log 语义）', () => {
|
||||
const txnId = mvcc.beginTransaction();
|
||||
mvcc.writeVersion('users', '1', { name: 'Alice', age: 30 }, txnId);
|
||||
mvcc.writeVersion('users', '1', { name: 'Alice', age: 31 }, txnId);
|
||||
const store = (mvcc as unknown as { versionStore: Map<string, { prevVersion: unknown }[]> }).versionStore;
|
||||
const versions = store.get('users.1')!;
|
||||
expect(versions).toHaveLength(2);
|
||||
expect(versions[1].prevVersion).not.toBeNull(); // 版本链
|
||||
});
|
||||
|
||||
it('deleteVersion 写入墓碑版本', () => {
|
||||
const txnId = mvcc.beginTransaction();
|
||||
mvcc.deleteVersion('users', '1', txnId);
|
||||
mvcc.commitTransaction(txnId);
|
||||
const store = (mvcc as unknown as { versionStore: Map<string, { data: Record<string, unknown>; committed: boolean }[]> }).versionStore;
|
||||
const versions = store.get('users.1')!;
|
||||
expect(versions[0].committed).toBe(true);
|
||||
expect((versions[0].data as unknown as { __mvcc_tombstone: boolean }).__mvcc_tombstone).toBe(true);
|
||||
});
|
||||
|
||||
it('活跃事务可并发登记', () => {
|
||||
const t1 = mvcc.beginTransaction();
|
||||
const t2 = mvcc.beginTransaction();
|
||||
mvcc.writeVersion('users', '1', { v: 1 }, t1);
|
||||
mvcc.writeVersion('users', '2', { v: 2 }, t2);
|
||||
// 两个事务的写入各自独立记录
|
||||
const store = (mvcc as unknown as { versionStore: Map<string, unknown[]> }).versionStore;
|
||||
expect(store.has('users.1')).toBe(true);
|
||||
expect(store.has('users.2')).toBe(true);
|
||||
});
|
||||
|
||||
it('gc 清理过旧版本', () => {
|
||||
// 创建很多版本后 gc
|
||||
for (let i = 0; i < 200; i++) {
|
||||
const txnId = mvcc.beginTransaction();
|
||||
mvcc.writeVersion('users', '1', { ver: i }, txnId);
|
||||
mvcc.commitTransaction(txnId);
|
||||
}
|
||||
mvcc.gc(100);
|
||||
// gc 后版本保留最新 100 个
|
||||
const store = (mvcc as unknown as { versionStore: Map<string, unknown[]> }).versionStore;
|
||||
expect(store.get('users.1')!.length).toBe(100);
|
||||
// gc 后引擎仍可继续写入
|
||||
const txnId = mvcc.beginTransaction();
|
||||
mvcc.writeVersion('users', '1', { ver: 999 }, txnId);
|
||||
mvcc.commitTransaction(txnId);
|
||||
expect(store.get('users.1')!.length).toBe(101);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -0,0 +1,275 @@
|
||||
/**
|
||||
* AriaEngine — SegmentedWALStore 分片 WAL 存储测试
|
||||
*
|
||||
* 覆盖：
|
||||
* 1. append → readAll 往返（分片切换、字节顺序）
|
||||
* 2. 空洞检测：序号不连续 → 空洞后的分片丢弃
|
||||
* 3. 旧格式 __wal_N + __wal_count 兼容读取
|
||||
* 4. truncate / exists
|
||||
* 5. 后端无 append 接口时回退 read+write（正确性一致）
|
||||
* 6. AriaEngine 集成：高频写入跨重启数据完整（分片 + WAL 重放）
|
||||
*/
|
||||
import { SegmentedWALStore } from '../../src/engine/aria/wal/segmented_store';
|
||||
import { MemoryBackend } from '../../src/engine/aria/store/backend';
|
||||
import { AriaEngine } from '../../src/engine/aria/index';
|
||||
import { createSchema } from '../../src/table/schema';
|
||||
import 'fake-indexeddb/auto';
|
||||
|
||||
let idbCounter = 0;
|
||||
function uniqueDB(): string {
|
||||
return `seg-${Date.now()}-${++idbCounter}-${Math.random().toString(36).slice(2, 8)}`;
|
||||
}
|
||||
|
||||
const enc = (s: string) => new Uint8Array(new TextEncoder().encode(s));
|
||||
|
||||
describe('AriaEngine — SegmentedWALStore 单元', () => {
|
||||
it('append → readAll 往返，多批次字节顺序一致', async () => {
|
||||
const backend = new MemoryBackend();
|
||||
await backend.open('seg-unit-1');
|
||||
const store = new SegmentedWALStore(backend, 1024);
|
||||
|
||||
expect(await store.exists()).toBe(false);
|
||||
await store.append(enc('AAA'));
|
||||
await store.append(enc('BBB'));
|
||||
await store.append(enc('CCC'));
|
||||
expect(await store.exists()).toBe(true);
|
||||
|
||||
const all = await store.readAll();
|
||||
expect(new TextDecoder().decode(all)).toBe('AAABBBCCC');
|
||||
|
||||
// 后端是分片文件（单个 key）
|
||||
const keys = await backend.listKeys();
|
||||
expect(keys).toEqual(['__wal_000000.bin']);
|
||||
await backend.close();
|
||||
});
|
||||
|
||||
it('超过分片阈值自动切换分片', async () => {
|
||||
const backend = new MemoryBackend();
|
||||
await backend.open('seg-unit-2');
|
||||
const store = new SegmentedWALStore(backend, 16); // 每分片 16 字节
|
||||
|
||||
await store.append(enc('AAAAAAAAAA')); // 10B → 分片 0
|
||||
await store.append(enc('BBBBBBBBBB')); // 10B → 分片 1（0 已 10B+10B > 16）
|
||||
await store.append(enc('CC')); // 2B → 分片 1（10+2 <= 16）
|
||||
|
||||
const all = await store.readAll();
|
||||
expect(new TextDecoder().decode(all)).toBe('AAAAAAAAAABBBBBBBBBBCC');
|
||||
const keys = await backend.listKeys().then((ks) => ks.sort());
|
||||
expect(keys).toEqual(['__wal_000000.bin', '__wal_000001.bin']);
|
||||
await backend.close();
|
||||
});
|
||||
|
||||
it('空洞检测：分片序号不连续 → 空洞后的分片整体丢弃', async () => {
|
||||
const backend = new MemoryBackend();
|
||||
await backend.open('seg-unit-3');
|
||||
const store = new SegmentedWALStore(backend, 16);
|
||||
|
||||
await store.append(enc('SEG0-SEG0-S')); // 10B → 分片 0
|
||||
await store.append(enc('SEG1-SEG1-S')); // 10B → 分片 1（0 已 10B+10B > 16）
|
||||
await store.append(enc('S2')); // 2B → 分片 1（10+2 <= 16）
|
||||
|
||||
// 模拟 truncate 部分完成：删除分片 1（空洞）
|
||||
await backend.delete('__wal_000001.bin');
|
||||
|
||||
const all = await store.readAll();
|
||||
// 空洞在分片 1 → 1 及之后丢弃，只保留分片 0
|
||||
expect(new TextDecoder().decode(all)).toBe('SEG0-SEG0-S');
|
||||
await backend.close();
|
||||
});
|
||||
|
||||
it('空洞在开头（分片 0 缺失）→ 全部丢弃（保守截断）', async () => {
|
||||
const backend = new MemoryBackend();
|
||||
await backend.open('seg-unit-4');
|
||||
const store = new SegmentedWALStore(backend, 16);
|
||||
await store.append(enc('X0'));
|
||||
await store.append(enc('X1'));
|
||||
await backend.delete('__wal_000000.bin');
|
||||
|
||||
const all = await store.readAll();
|
||||
expect(all.byteLength).toBe(0);
|
||||
await backend.close();
|
||||
});
|
||||
|
||||
it('旧格式 __wal_N + __wal_count 兼容读取（迁移前数据）', async () => {
|
||||
const backend = new MemoryBackend();
|
||||
await backend.open('seg-unit-5');
|
||||
// 构造旧格式数据
|
||||
await backend.write('__wal_0', enc('LEGACY0').buffer);
|
||||
await backend.write('__wal_1', enc('LEGACY1').buffer);
|
||||
await backend.write('__wal_count', enc('2').buffer);
|
||||
|
||||
const store = new SegmentedWALStore(backend, 1024);
|
||||
expect(await store.exists()).toBe(true);
|
||||
const all = await store.readAll();
|
||||
expect(new TextDecoder().decode(all)).toBe('LEGACY0LEGACY1');
|
||||
|
||||
// 迁移中追加新格式：新记录写入分片文件（不与旧键冲突）
|
||||
await store.append(enc('NEW'));
|
||||
const keys = await backend.listKeys().then((ks) => ks.sort());
|
||||
expect(keys).toContain('__wal_000000.bin');
|
||||
expect(keys).toContain('__wal_0');
|
||||
|
||||
// truncate 清空新旧全部
|
||||
await store.truncate();
|
||||
expect(await store.exists()).toBe(false);
|
||||
expect((await backend.listKeys()).length).toBe(0);
|
||||
await backend.close();
|
||||
});
|
||||
|
||||
it('truncate 清空分片并重置状态', async () => {
|
||||
const backend = new MemoryBackend();
|
||||
await backend.open('seg-unit-6');
|
||||
const store = new SegmentedWALStore(backend, 16);
|
||||
await store.append(enc('AAAAAA'));
|
||||
await store.append(enc('BBBBBB'));
|
||||
await store.truncate();
|
||||
expect(await store.exists()).toBe(false);
|
||||
expect((await backend.listKeys()).length).toBe(0);
|
||||
|
||||
// 截断后继续追加从分片 0 重新开始
|
||||
await store.append(enc('CCC'));
|
||||
const all = await store.readAll();
|
||||
expect(new TextDecoder().decode(all)).toBe('CCC');
|
||||
await backend.close();
|
||||
});
|
||||
|
||||
it('后端无 append 接口 → 回退 read+write 语义一致', async () => {
|
||||
// MemoryBackend 没有 append 接口 → 走回退路径
|
||||
const backend = new MemoryBackend();
|
||||
await backend.open('seg-unit-7');
|
||||
const store = new SegmentedWALStore(backend, 1024);
|
||||
await store.append(enc('PART1'));
|
||||
await store.append(enc('PART2'));
|
||||
const all = await store.readAll();
|
||||
expect(new TextDecoder().decode(all)).toBe('PART1PART2');
|
||||
await backend.close();
|
||||
});
|
||||
});
|
||||
|
||||
// ===================================================================
|
||||
// AriaEngine 集成 — 分片 WAL 跨重启
|
||||
// ===================================================================
|
||||
describe('AriaEngine — 分片 WAL 集成', () => {
|
||||
it('高频写入（多条 WAL 记录）→ close → reopen 数据完整', async () => {
|
||||
const dbName = uniqueDB();
|
||||
const engine = new AriaEngine({
|
||||
storageBackend: 'indexeddb',
|
||||
checkpointInterval: 100000,
|
||||
walSyncMode: 'full',
|
||||
});
|
||||
await engine.open(dbName, 1);
|
||||
await engine.createTable(createSchema('logs', {
|
||||
id: { type: 'string', primaryKey: true },
|
||||
msg: { type: 'string' },
|
||||
}));
|
||||
const total = 300;
|
||||
for (let i = 0; i < total; i++) {
|
||||
await engine.insert('logs', [{ id: `log-${i}`, msg: `message ${i}` }]);
|
||||
}
|
||||
// 不 flush 不 checkpoint，全部留在 WAL → 模拟崩溃后重放
|
||||
await (engine as any).backend.close();
|
||||
(engine as any).opened = false;
|
||||
|
||||
const engine2 = new AriaEngine({
|
||||
storageBackend: 'indexeddb',
|
||||
checkpointInterval: 100000,
|
||||
walSyncMode: 'full',
|
||||
});
|
||||
await engine2.open(dbName, 1);
|
||||
const rows = await engine2.find('logs', { table: 'logs' });
|
||||
expect(rows).toHaveLength(total);
|
||||
expect(rows.some((r) => r.id === 'log-299')).toBe(true);
|
||||
await engine2.close();
|
||||
});
|
||||
|
||||
it('分片结构落盘验证（backend 中是分片文件而非旧单记录键）', async () => {
|
||||
const dbName = uniqueDB();
|
||||
const engine = new AriaEngine({
|
||||
storageBackend: 'indexeddb',
|
||||
checkpointInterval: 100000,
|
||||
walSyncMode: 'full',
|
||||
});
|
||||
await engine.open(dbName, 1);
|
||||
await engine.createTable(createSchema('t', {
|
||||
id: { type: 'string', primaryKey: true },
|
||||
}));
|
||||
await engine.insert('t', [{ id: '1' }, { id: '2' }, { id: '3' }]);
|
||||
|
||||
const backend = (engine as any).backend;
|
||||
const keys = await backend.listKeys();
|
||||
const walKeys = keys.filter((k: string) => k.startsWith('__wal_'));
|
||||
// 新格式：__wal_000000.bin；无旧格式单记录键与 count 键
|
||||
expect(walKeys).toContain('__wal_000000.bin');
|
||||
expect(walKeys.some((k: string) => /^__wal_\d+$/.test(k) && !k.endsWith('.bin'))).toBe(false);
|
||||
expect(walKeys).not.toContain('__wal_count');
|
||||
await engine.close();
|
||||
});
|
||||
|
||||
it('WAL 分片部分残留（空洞）→ 重开恢复已落盘数据，不丢已 checkpoint 数据', async () => {
|
||||
const dbName = uniqueDB();
|
||||
const engine = new AriaEngine({
|
||||
storageBackend: 'indexeddb',
|
||||
checkpointInterval: 100000,
|
||||
walSyncMode: 'full',
|
||||
});
|
||||
await engine.open(dbName, 1);
|
||||
await engine.createTable(createSchema('t', {
|
||||
id: { type: 'string', primaryKey: true },
|
||||
}));
|
||||
// 第一批：flush 落盘 + checkpoint 清 WAL
|
||||
await engine.insert('t', [{ id: 'a' }, { id: 'b' }]);
|
||||
await (engine as any).lsm.flush();
|
||||
await (engine as any).wal.checkpoint();
|
||||
// 第二批：只进 WAL（不 flush）
|
||||
await engine.insert('t', [{ id: 'c' }, { id: 'd' }]);
|
||||
|
||||
// 模拟 WAL 分片文件被外部删掉（空洞场景）
|
||||
const backend = (engine as any).backend;
|
||||
await backend.delete('__wal_000000.bin');
|
||||
|
||||
await engine.close();
|
||||
const engine2 = new AriaEngine({ storageBackend: 'indexeddb', checkpointInterval: 100000 });
|
||||
await engine2.open(dbName, 1);
|
||||
// 已落盘的 a/b 必须保留；c/d 在 WAL 中且文件被删 → 恢复不到（可接受的保守丢弃）
|
||||
const rows = await engine2.find('t', { table: 't' });
|
||||
expect(rows.some((r) => r.id === 'a')).toBe(true);
|
||||
expect(rows.some((r) => r.id === 'b')).toBe(true);
|
||||
await engine2.close();
|
||||
});
|
||||
|
||||
it('旧格式 WAL 升级迁移：旧键重放后 checkpoint 清空', async () => {
|
||||
const dbName = uniqueDB();
|
||||
// 手工构造旧格式 WAL 库：直接写旧键（模拟 v0.4.4 库崩溃现场）
|
||||
const engine = new AriaEngine({
|
||||
storageBackend: 'indexeddb',
|
||||
checkpointInterval: 100000,
|
||||
walSyncMode: 'full',
|
||||
});
|
||||
await engine.open(dbName, 1);
|
||||
await engine.createTable(createSchema('t', {
|
||||
id: { type: 'string', primaryKey: true },
|
||||
}));
|
||||
// 写入一批数据但只保留在 WAL（新格式）→ close 前手工转成旧格式
|
||||
await engine.insert('t', [{ id: 'x' }]);
|
||||
const backend = (engine as any).backend;
|
||||
const raw = await backend.read('__wal_000000.bin');
|
||||
expect(raw).not.toBeNull();
|
||||
// 清掉新格式，写成旧格式（单记录键）
|
||||
await backend.delete('__wal_000000.bin');
|
||||
await backend.write('__wal_0', raw);
|
||||
await backend.write('__wal_count', new TextEncoder().encode('1').buffer);
|
||||
// 同时清掉内存里的 WAL 状态，模拟"重启"
|
||||
await (engine as any).backend.close();
|
||||
(engine as any).opened = false;
|
||||
|
||||
const engine2 = new AriaEngine({ storageBackend: 'indexeddb', checkpointInterval: 100000 });
|
||||
await engine2.open(dbName, 1);
|
||||
const rows = await engine2.find('t', { table: 't' });
|
||||
expect(rows).toHaveLength(1);
|
||||
expect(rows[0].id).toBe('x');
|
||||
// 恢复后 checkpoint 清空旧键
|
||||
const keys = await (engine2 as any).backend.listKeys();
|
||||
expect(keys.some((k: string) => k.startsWith('__wal_'))).toBe(false);
|
||||
await engine2.close();
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,89 @@
|
||||
/**
|
||||
* AriaEngine CRC32 单元测试
|
||||
*/
|
||||
import { crc32, crc32Continue } from '../../src/engine/aria/crc32';
|
||||
|
||||
const enc = new TextEncoder();
|
||||
|
||||
function bytes(s: string): Uint8Array {
|
||||
return enc.encode(s);
|
||||
}
|
||||
|
||||
describe('CRC32', () => {
|
||||
test('标准测试向量：空串 = 0', () => {
|
||||
expect(crc32(new Uint8Array(0))).toBe(0x00000000);
|
||||
});
|
||||
|
||||
test('标准测试向量：123456789 = 0xCBF43926（IEEE 802.3 参考值）', () => {
|
||||
expect(crc32(bytes('123456789'))).toBe(0xcbf43926);
|
||||
});
|
||||
|
||||
test('标准测试向量：The quick brown fox... = 0x414FA339', () => {
|
||||
expect(crc32(bytes('The quick brown fox jumps over the lazy dog'))).toBe(0x414fa339);
|
||||
});
|
||||
|
||||
test('确定性：相同输入多次计算一致', () => {
|
||||
const data = bytes('metona-sqlark aria engine');
|
||||
const a = crc32(data);
|
||||
const b = crc32(data);
|
||||
expect(a).toBe(b);
|
||||
});
|
||||
|
||||
test('区分性：不同输入不同校验和', () => {
|
||||
expect(crc32(bytes('hello'))).not.toBe(crc32(bytes('hellp')));
|
||||
expect(crc32(bytes('abc'))).not.toBe(crc32(bytes('abd')));
|
||||
});
|
||||
|
||||
test('单字节翻转可被检测', () => {
|
||||
const original = bytes('metona-sqlark aria engine');
|
||||
const flipped = new Uint8Array(original);
|
||||
flipped[10] ^= 0xff;
|
||||
expect(crc32(original)).not.toBe(crc32(flipped));
|
||||
});
|
||||
|
||||
test('分段计算与一次性计算一致（crc32Continue）', () => {
|
||||
const data = bytes('The quick brown fox jumps over the lazy dog');
|
||||
const whole = crc32(data);
|
||||
|
||||
// 按 1 字节分段
|
||||
let seg = 0;
|
||||
for (let i = 0; i < data.length; i++) {
|
||||
seg = crc32Continue(seg, data.subarray(i, i + 1));
|
||||
}
|
||||
expect(seg).toBe(whole);
|
||||
|
||||
// 按 5 字节分段
|
||||
let seg2 = 0;
|
||||
for (let i = 0; i < data.length; i += 5) {
|
||||
seg2 = crc32Continue(seg2, data.subarray(i, i + 5));
|
||||
}
|
||||
expect(seg2).toBe(whole);
|
||||
});
|
||||
|
||||
test('seed 参数与 crc32Continue 等价', () => {
|
||||
const data = bytes('metona-sqlark aria engine');
|
||||
const head = data.subarray(0, 7);
|
||||
const tail = data.subarray(7);
|
||||
const whole = crc32(data);
|
||||
const split = crc32(tail, crc32(head));
|
||||
expect(split).toBe(whole);
|
||||
});
|
||||
|
||||
test('中文 UTF-8 字节正确参与计算', () => {
|
||||
const data = bytes('玥玥的测试数据：大段中文内容');
|
||||
expect(crc32(data)).toBe(crc32(new Uint8Array(data)));
|
||||
});
|
||||
|
||||
test('大缓冲区（1MB 随机字节）稳定计算', () => {
|
||||
const data = new Uint8Array(1024 * 1024);
|
||||
let x = 12345;
|
||||
for (let i = 0; i < data.length; i++) {
|
||||
x = (x * 1103515245 + 12345) & 0x7fffffff;
|
||||
data[i] = x & 0xff;
|
||||
}
|
||||
const a = crc32(data);
|
||||
const b = crc32(data);
|
||||
expect(a).toBe(b);
|
||||
expect(a).not.toBe(0);
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user