MetonaSqlark/tests/hybrid/index.test.ts

/**
 * HybridEngine 测试 — write-through 策略验证
 * 注：re-open 持久化测试需要真实 IndexedDB 版本管理，fake-indexeddb 不支持。
 * 这里验证 write-through 即时效正确性。
 */

import { HybridEngine } from '../../src/hybrid/index';
import { createSchema } from '../../src/table/schema';
import 'fake-indexeddb/auto';

let hybridCounter = 0;

describe('HybridEngine', () => {
  let engine: HybridEngine;
  let dbName: string;

  const userSchema = createSchema('users', {
    id: { type: 'string', primaryKey: true },
    name: { type: 'string', required: true },
    age: { type: 'number', default: 0 },
  });

  beforeEach(async () => {
    dbName = `test-hybrid-${++hybridCounter}`;
    engine = new HybridEngine('indexeddb');
    await engine.open(dbName, 1);
  });

  afterEach(async () => {
    if (engine.isOpen()) {
      await engine.close();
    }
    try { indexedDB.deleteDatabase(dbName); } catch {}
  });

  it('引擎名称', () => {
    expect(engine.name).toBe('hybrid');
  });

  it('磁盘引擎类型', () => {
    expect(engine.getDiskEngineType()).toBe('indexeddb');
  });

  describe('表管理', () => {
    it('创建表', async () => {
      await engine.createTable(userSchema);
      expect(await engine.hasTable('users')).toBe(true);
    });

    it('删除表', async () => {
      await engine.createTable(userSchema);
      await engine.dropTable('users');
      expect(await engine.hasTable('users')).toBe(false);
    });

    it('表名列表', async () => {
      await engine.createTable(userSchema);
      const names = await engine.getTableNames();
      expect(names).toContain('users');
    });

    it('获取表结构', async () => {
      await engine.createTable(userSchema);
      const schema = await engine.getTableSchema('users');
      expect(schema).not.toBeNull();
      expect(schema!.name).toBe('users');
    });
  });

  describe('Write-Through 即时性', () => {
    beforeEach(async () => {
      await engine.createTable(userSchema);
    });

    it('插入后内存立即可读', async () => {
      await engine.insert('users', [
        { id: '1', name: 'Alice', age: 30 },
        { id: '2', name: 'Bob', age: 25 },
      ]);
      const data = await engine.find('users', { table: 'users' });
      expect(data).toHaveLength(2);
      expect(await engine.count('users')).toBe(2);
    });

    it('更新后立即可读', async () => {
      await engine.insert('users', [
        { id: '1', name: 'Alice', age: 30 },
      ]);
      await engine.update('users', { table: 'users', where: { id: '1' } }, { age: 31 });
      const rows = await engine.find('users', { table: 'users' });
      expect(rows[0].age).toBe(31);
    });

    it('删除后立即可读', async () => {
      await engine.insert('users', [
        { id: '1', name: 'Alice', age: 30 },
        { id: '2', name: 'Bob', age: 25 },
      ]);
      await engine.delete('users', { table: 'users', where: { id: '1' } });
      expect(await engine.count('users')).toBe(1);
      const rows = await engine.find('users', { table: 'users' });
      expect(rows.map(r => r.id)).toEqual(['2']);
    });

    it('查询带排序和分页', async () => {
      await engine.insert('users', [
        { id: '1', name: 'Alice', age: 30 },
        { id: '2', name: 'Bob', age: 25 },
        { id: '3', name: 'Charlie', age: 35 },
      ]);
      const rows = await engine.find('users', {
        table: 'users',
        orderBy: [{ column: 'age', direction: 'desc' }],
        limit: 2,
      });
      expect(rows.map(r => r.age)).toEqual([35, 30]);
    });

    it('clear 清空表', async () => {
      await engine.insert('users', [{ id: '1', name: 'Alice', age: 30 }]);
      await engine.clear('users');
      expect(await engine.count('users')).toBe(0);
    });
  });

  describe('生命周期', () => {
    it('isOpen 状态', async () => {
      expect(engine.isOpen()).toBe(true);
      await engine.close();
      expect(engine.isOpen()).toBe(false);
    });
  });

  describe('内存引擎访问', () => {
    it('getMemoryEngine 返回内存引擎', () => {
      const mem = engine.getMemoryEngine();
      expect(mem.name).toBe('memory');
    });
  });
});