orez 0.2.27 → 0.2.30

package/src/worker/shims/sqlite.test.ts

@@ -1,786 +0,0 @@
-/**
- * sqlite shim tests.
- *
- * uses a mock SqlStorageLike backed by better-sqlite3 to validate that our
- * shim correctly bridges between the better-sqlite3 api and DO SqlStorage.
- */
-
-// @ts-expect-error - CJS module
-import BedrockSqlite from 'bedrock-sqlite'
-const BetterSqlite3 = BedrockSqlite.Database
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-
-import {
-  Database,
-  Statement,
-  StatementRunner,
-  SqliteError,
-  type SqlStorageLike,
-  type SqlStorageCursor,
-  type SqlStorageValue,
-} from './sqlite.js'
-
-// -- mock SqlStorageLike backed by better-sqlite3 --
-
-function createMockSqlStorage(): SqlStorageLike {
-  const nativeDb = new BetterSqlite3(':memory:')
-
-  return {
-    exec(query: string, ...bindings: SqlStorageValue[]): SqlStorageCursor {
-      const trimmed = query.trim()
-
-      // handle statements that don't return rows
-      const isWrite =
-        /^(INSERT|UPDATE|DELETE|CREATE|DROP|ALTER|BEGIN|COMMIT|ROLLBACK|PRAGMA|SAVEPOINT|RELEASE|VACUUM)/i.test(
-          trimmed
-        )
-
-      if (isWrite && !trimmed.toUpperCase().startsWith('PRAGMA')) {
-        const stmt = nativeDb.prepare(query)
-        const result = stmt.run(...bindings)
-        return {
-          toArray: () => [],
-          get rowsRead() {
-            return 0
-          },
-          get rowsWritten() {
-            return result.changes
-          },
-          get columnNames() {
-            return []
-          },
-        }
-      }
-
-      // for pragmas — some are SET (contain =), some are GET
-      if (trimmed.toUpperCase().startsWith('PRAGMA')) {
-        try {
-          const stmt = nativeDb.prepare(query)
-          const rows = stmt.all(...bindings)
-          return {
-            toArray: () => rows as Record<string, SqlStorageValue>[],
-            get rowsRead() {
-              return rows.length
-            },
-            get rowsWritten() {
-              return 0
-            },
-            get columnNames() {
-              if (rows.length > 0) return Object.keys(rows[0] as object)
-              return []
-            },
-          }
-        } catch {
-          // pragma that modifies state (e.g., journal_mode = WAL)
-          nativeDb.pragma(query.replace(/^PRAGMA\s+/i, ''))
-          return {
-            toArray: () => [],
-            get rowsRead() {
-              return 0
-            },
-            get rowsWritten() {
-              return 0
-            },
-            get columnNames() {
-              return []
-            },
-          }
-        }
-      }
-
-      // select / other read queries
-      const stmt = nativeDb.prepare(query)
-      const rows = stmt.all(...bindings)
-      const columns = stmt.columns().map((c: { name: string }) => c.name)
-      return {
-        toArray: () => rows as Record<string, SqlStorageValue>[],
-        get rowsRead() {
-          return rows.length
-        },
-        get rowsWritten() {
-          return 0
-        },
-        get columnNames() {
-          return columns
-        },
-      }
-    },
-    // expose native db for cleanup
-    _nativeDb: nativeDb,
-  } as SqlStorageLike & { _nativeDb: typeof nativeDb }
-}
-
-// -- tests --
-
-describe('SqliteError', () => {
-  it('creates error with message and code', () => {
-    const err = new SqliteError('table not found', 'SQLITE_ERROR')
-    expect(err).toBeInstanceOf(Error)
-    expect(err).toBeInstanceOf(SqliteError)
-    expect(err.message).toBe('table not found')
-    expect(err.code).toBe('SQLITE_ERROR')
-    expect(err.name).toBe('SqliteError')
-  })
-
-  it('captures stack trace', () => {
-    const err = new SqliteError('test', 'SQLITE_MISUSE')
-    expect(err.stack).toBeDefined()
-    expect(err.stack).toContain('SqliteError')
-  })
-})
-
-describe('Database', () => {
-  let mock: SqlStorageLike & { _nativeDb: any }
-  let db: Database
-
-  beforeEach(() => {
-    mock = createMockSqlStorage() as SqlStorageLike & { _nativeDb: any }
-    db = new Database(mock)
-  })
-
-  afterEach(() => {
-    db.close()
-    mock._nativeDb.close()
-  })
-
-  it('constructs with SqlStorageLike', () => {
-    expect(db.open).toBe(true)
-    expect(db.name).toBe(':do-storage:')
-    expect(db.inTransaction).toBe(false)
-  })
-
-  it('throws when constructed with a string and no globalThis storage', () => {
-    // clear any global DO storage
-    const prev = (globalThis as any).__orez_do_sqlite
-    delete (globalThis as any).__orez_do_sqlite
-    try {
-      expect(() => new Database('/path/to/db' as unknown as SqlStorageLike)).toThrow(
-        'no DO storage on globalThis.__orez_do_sqlite'
-      )
-    } finally {
-      if (prev) (globalThis as any).__orez_do_sqlite = prev
-    }
-  })
-
-  it('close sets open to false', () => {
-    expect(db.open).toBe(true)
-    const ret = db.close()
-    expect(db.open).toBe(false)
-    expect(ret).toBe(db) // chainable
-  })
-
-  it('unsafeMode is a no-op that returns this', () => {
-    expect(db.unsafeMode(true)).toBe(db)
-    expect(db.unsafeMode(false)).toBe(db)
-    expect(db.unsafeMode()).toBe(db)
-  })
-
-  it('defaultSafeIntegers is a no-op that returns this', () => {
-    expect(db.defaultSafeIntegers(true)).toBe(db)
-  })
-})
-
-describe('Database.exec', () => {
-  let mock: SqlStorageLike & { _nativeDb: any }
-  let db: Database
-
-  beforeEach(() => {
-    mock = createMockSqlStorage() as SqlStorageLike & { _nativeDb: any }
-    db = new Database(mock)
-  })
-
-  afterEach(() => {
-    db.close()
-    mock._nativeDb.close()
-  })
-
-  it('executes single statement', () => {
-    const ret = db.exec('CREATE TABLE t (id INTEGER PRIMARY KEY)')
-    expect(ret).toBe(db) // chainable
-  })
-
-  it('executes multiple statements separated by semicolons', () => {
-    db.exec(
-      'CREATE TABLE t (id INTEGER PRIMARY KEY); CREATE TABLE t2 (id INTEGER PRIMARY KEY)'
-    )
-    // verify both tables exist
-    const r1 = db
-      .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='t'")
-      .get()
-    const r2 = db
-      .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='t2'")
-      .get()
-    expect(r1).toEqual({ name: 't' })
-    expect(r2).toEqual({ name: 't2' })
-  })
-
-  it('throws on closed database', () => {
-    db.close()
-    expect(() => db.exec('SELECT 1')).toThrow('not open')
-  })
-})
-
-describe('Database.prepare / Statement', () => {
-  let mock: SqlStorageLike & { _nativeDb: any }
-  let db: Database
-
-  beforeEach(() => {
-    mock = createMockSqlStorage() as SqlStorageLike & { _nativeDb: any }
-    db = new Database(mock)
-    db.exec('CREATE TABLE items (id INTEGER PRIMARY KEY, name TEXT, val INTEGER)')
-  })
-
-  afterEach(() => {
-    db.close()
-    mock._nativeDb.close()
-  })
-
-  it('prepare returns a Statement', () => {
-    const stmt = db.prepare('SELECT 1 as x')
-    expect(stmt).toBeInstanceOf(Statement)
-    expect(stmt.source).toBe('SELECT 1 as x')
-  })
-
-  it('throws prepare on closed db', () => {
-    db.close()
-    expect(() => db.prepare('SELECT 1')).toThrow('not open')
-  })
-
-  it('run executes write and returns RunResult', () => {
-    const result = db
-      .prepare('INSERT INTO items (name, val) VALUES (?, ?)')
-      .run('foo', 42)
-    expect(result).toHaveProperty('changes')
-    expect(result).toHaveProperty('lastInsertRowid')
-    expect(result.changes).toBe(1)
-  })
-
-  it('get returns first row or undefined', () => {
-    db.prepare('INSERT INTO items (name, val) VALUES (?, ?)').run('a', 1)
-    db.prepare('INSERT INTO items (name, val) VALUES (?, ?)').run('b', 2)
-
-    const row = db.prepare('SELECT * FROM items WHERE name = ?').get('a')
-    expect(row).toEqual({ id: 1, name: 'a', val: 1 })
-
-    const missing = db.prepare('SELECT * FROM items WHERE name = ?').get('zzz')
-    expect(missing).toBeUndefined()
-  })
-
-  it('all returns all rows', () => {
-    db.prepare('INSERT INTO items (name, val) VALUES (?, ?)').run('x', 10)
-    db.prepare('INSERT INTO items (name, val) VALUES (?, ?)').run('y', 20)
-
-    const rows = db.prepare('SELECT * FROM items ORDER BY id').all()
-    expect(rows).toEqual([
-      { id: 1, name: 'x', val: 10 },
-      { id: 2, name: 'y', val: 20 },
-    ])
-  })
-
-  it('all returns empty array when no rows', () => {
-    const rows = db.prepare('SELECT * FROM items').all()
-    expect(rows).toEqual([])
-  })
-
-  it('iterate yields rows lazily', () => {
-    db.prepare('INSERT INTO items (name, val) VALUES (?, ?)').run('a', 1)
-    db.prepare('INSERT INTO items (name, val) VALUES (?, ?)').run('b', 2)
-
-    const iter = db.prepare('SELECT * FROM items ORDER BY id').iterate()
-    const results: unknown[] = []
-    for (const row of iter) {
-      results.push(row)
-    }
-    expect(results).toEqual([
-      { id: 1, name: 'a', val: 1 },
-      { id: 2, name: 'b', val: 2 },
-    ])
-  })
-
-  it('safeIntegers is a no-op returning this', () => {
-    const stmt = db.prepare('SELECT 1 as x')
-    expect(stmt.safeIntegers(true)).toBe(stmt)
-    expect(stmt.safeIntegers()).toBe(stmt)
-  })
-
-  it('statement methods throw on closed db', () => {
-    const stmt = db.prepare('SELECT 1 as x')
-    db.close()
-    expect(() => stmt.run()).toThrow('not open')
-    expect(() => stmt.get()).toThrow('not open')
-    expect(() => stmt.all()).toThrow('not open')
-  })
-})
-
-describe('Database.pragma', () => {
-  let mock: SqlStorageLike & { _nativeDb: any }
-  let db: Database
-
-  beforeEach(() => {
-    mock = createMockSqlStorage() as SqlStorageLike & { _nativeDb: any }
-    db = new Database(mock)
-  })
-
-  afterEach(() => {
-    mock._nativeDb.close()
-  })
-
-  it('reads a pragma and returns array of objects', () => {
-    const result = db.pragma('journal_mode')
-    expect(Array.isArray(result)).toBe(true)
-    expect((result as unknown[]).length).toBeGreaterThan(0)
-  })
-
-  it('reads pragma with simple option', () => {
-    const result = db.pragma('journal_mode', { simple: true })
-    // should return a scalar value, not an array
-    expect(Array.isArray(result)).toBe(false)
-    expect(typeof result).toBe('string')
-  })
-
-  it('sets a pragma', () => {
-    const result = db.pragma('cache_size = 2000')
-    // set pragmas return the new value or empty
-    expect(Array.isArray(result)).toBe(true)
-  })
-
-  it('skips optimize pragma', () => {
-    const result = db.pragma('optimize')
-    expect(result).toEqual([])
-
-    const simple = db.pragma('optimize', { simple: true })
-    expect(simple).toBeUndefined()
-  })
-
-  it('throws on closed db', () => {
-    db.close()
-    expect(() => db.pragma('journal_mode')).toThrow('not open')
-  })
-})
-
-describe('Database.transaction', () => {
-  let mock: SqlStorageLike & { _nativeDb: any }
-  let db: Database
-
-  beforeEach(() => {
-    mock = createMockSqlStorage() as SqlStorageLike & { _nativeDb: any }
-    db = new Database(mock)
-    db.exec('CREATE TABLE t (id INTEGER PRIMARY KEY)')
-  })
-
-  afterEach(() => {
-    mock._nativeDb.close()
-  })
-
-  it('commits on success', () => {
-    const txn = db.transaction(() => {
-      db.prepare('INSERT INTO t VALUES (1)').run()
-      db.prepare('INSERT INTO t VALUES (2)').run()
-    })
-
-    txn()
-
-    const rows = db.prepare('SELECT * FROM t').all()
-    expect(rows).toEqual([{ id: 1 }, { id: 2 }])
-  })
-
-  it('rolls back on error', () => {
-    const txn = db.transaction(() => {
-      db.prepare('INSERT INTO t VALUES (1)').run()
-      throw new Error('boom')
-    })
-
-    expect(() => txn()).toThrow('boom')
-
-    const rows = db.prepare('SELECT * FROM t').all()
-    expect(rows).toEqual([])
-  })
-
-  it('inTransaction reflects state', () => {
-    expect(db.inTransaction).toBe(false)
-
-    db.transaction(() => {
-      expect(db.inTransaction).toBe(true)
-    })()
-
-    expect(db.inTransaction).toBe(false)
-  })
-
-  it('inTransaction is false after rollback', () => {
-    try {
-      db.transaction(() => {
-        throw new Error('fail')
-      })()
-    } catch {}
-
-    expect(db.inTransaction).toBe(false)
-  })
-
-  it('has deferred/immediate/exclusive variants', () => {
-    const txn = db.transaction(() => {
-      db.prepare('INSERT INTO t VALUES (99)').run()
-    })
-
-    expect(typeof txn.deferred).toBe('function')
-    expect(typeof txn.immediate).toBe('function')
-    expect(typeof txn.exclusive).toBe('function')
-  })
-
-  it('immediate variant works', () => {
-    const txn = db.transaction(() => {
-      db.prepare('INSERT INTO t VALUES (42)').run()
-    })
-
-    txn.immediate()
-
-    const rows = db.prepare('SELECT * FROM t').all()
-    expect(rows).toEqual([{ id: 42 }])
-  })
-
-  it('nested transaction calls run fn without extra BEGIN', () => {
-    const inner = db.transaction(() => {
-      db.prepare('INSERT INTO t VALUES (2)').run()
-    })
-
-    const outer = db.transaction(() => {
-      db.prepare('INSERT INTO t VALUES (1)').run()
-      inner() // should NOT issue another BEGIN
-      db.prepare('INSERT INTO t VALUES (3)').run()
-    })
-
-    outer()
-
-    const rows = db.prepare('SELECT * FROM t ORDER BY id').all()
-    expect(rows).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }])
-  })
-
-  it('passes arguments through to wrapped function', () => {
-    const txn = db.transaction((id: unknown, val: unknown) => {
-      db.prepare('INSERT INTO t VALUES (?)').run(id)
-      return val
-    })
-
-    const result = txn(7, 'hello')
-    expect(result).toBe('hello')
-    expect(db.prepare('SELECT * FROM t').all()).toEqual([{ id: 7 }])
-  })
-})
-
-describe('StatementRunner', () => {
-  let mock: SqlStorageLike & { _nativeDb: any }
-  let db: Database
-  let runner: StatementRunner
-
-  beforeEach(() => {
-    mock = createMockSqlStorage() as SqlStorageLike & { _nativeDb: any }
-    db = new Database(mock)
-    db.exec('CREATE TABLE foo (id INTEGER PRIMARY KEY, name TEXT)')
-    runner = new StatementRunner(db)
-  })
-
-  afterEach(() => {
-    mock._nativeDb.close()
-  })
-
-  it('run inserts data', () => {
-    const result = runner.run('INSERT INTO foo (name) VALUES (?)', 'bar')
-    expect(result).toHaveProperty('changes')
-    expect(result.changes).toBe(1)
-  })
-
-  it('get returns single row', () => {
-    runner.run('INSERT INTO foo (name) VALUES (?)', 'baz')
-    const row = runner.get('SELECT * FROM foo WHERE name = ?', 'baz')
-    expect(row).toEqual({ id: 1, name: 'baz' })
-  })
-
-  it('get returns undefined for no match', () => {
-    const row = runner.get('SELECT * FROM foo WHERE name = ?', 'nope')
-    expect(row).toBeUndefined()
-  })
-
-  it('all returns all rows', () => {
-    runner.run('INSERT INTO foo (name) VALUES (?)', 'a')
-    runner.run('INSERT INTO foo (name) VALUES (?)', 'b')
-    const rows = runner.all('SELECT * FROM foo ORDER BY id')
-    expect(rows).toEqual([
-      { id: 1, name: 'a' },
-      { id: 2, name: 'b' },
-    ])
-  })
-
-  it('begin/commit transaction', () => {
-    runner.begin()
-    runner.run('INSERT INTO foo (name) VALUES (?)', 'x')
-    runner.run('INSERT INTO foo (name) VALUES (?)', 'y')
-    runner.commit()
-
-    expect(runner.all('SELECT * FROM foo ORDER BY id')).toEqual([
-      { id: 1, name: 'x' },
-      { id: 2, name: 'y' },
-    ])
-  })
-
-  it('begin/rollback discards changes', () => {
-    runner.begin()
-    runner.run('INSERT INTO foo (name) VALUES (?)', 'x')
-    runner.rollback()
-
-    expect(runner.all('SELECT * FROM foo')).toEqual([])
-  })
-
-  it('beginConcurrent maps to regular BEGIN', () => {
-    runner.beginConcurrent()
-    runner.run('INSERT INTO foo (name) VALUES (?)', 'concurrent')
-    runner.commit()
-
-    expect(runner.all('SELECT * FROM foo')).toEqual([{ id: 1, name: 'concurrent' }])
-  })
-
-  it('beginImmediate works', () => {
-    runner.beginImmediate()
-    runner.run('INSERT INTO foo (name) VALUES (?)', 'immediate')
-    runner.commit()
-
-    expect(runner.all('SELECT * FROM foo')).toEqual([{ id: 1, name: 'immediate' }])
-  })
-
-  it('caches prepared statements', () => {
-    // run same SQL multiple times — statements should be reused
-    runner.run('INSERT INTO foo (name) VALUES (?)', 'a')
-    runner.run('INSERT INTO foo (name) VALUES (?)', 'b')
-    runner.run('INSERT INTO foo (name) VALUES (?)', 'c')
-
-    expect(runner.all('SELECT count(*) as c FROM foo')).toEqual([{ c: 3 }])
-  })
-})
-
-describe('DO snapshot transactions', () => {
-  let mock: SqlStorageLike & { _nativeDb: any; transactionSync: <T>(fn: () => T) => T }
-  let live: Database
-  let snapshot: Database
-
-  beforeEach(() => {
-    mock = createMockSqlStorage() as SqlStorageLike & {
-      _nativeDb: any
-      transactionSync: <T>(fn: () => T) => T
-    }
-    mock.transactionSync = (fn) => fn()
-    live = new Database(mock)
-    snapshot = new Database(mock)
-    live.exec('CREATE TABLE todo (id TEXT PRIMARY KEY, title TEXT, _0_version TEXT)')
-    live.prepare('INSERT INTO todo VALUES (?, ?, ?)').run('1', 'old', '01')
-  })
-
-  afterEach(() => {
-    live.close()
-    snapshot.close()
-    mock._nativeDb.close()
-  })
-
-  it('keeps BEGIN CONCURRENT reads stable until rollback', () => {
-    snapshot.prepare('BEGIN CONCURRENT').run()
-    expect(snapshot.prepare('SELECT title FROM todo WHERE id = ?').get('1')).toEqual({
-      title: 'old',
-    })
-
-    live
-      .prepare('UPDATE todo SET title = ?, _0_version = ? WHERE id = ?')
-      .run('new', '02', '1')
-
-    expect(live.prepare('SELECT title FROM todo WHERE id = ?').get('1')).toEqual({
-      title: 'new',
-    })
-    expect(snapshot.prepare('SELECT title FROM todo WHERE id = ?').get('1')).toEqual({
-      title: 'old',
-    })
-
-    snapshot.prepare('ROLLBACK').run()
-    expect(snapshot.prepare('SELECT title FROM todo WHERE id = ?').get('1')).toEqual({
-      title: 'new',
-    })
-  })
-
-  it('hides snapshot tables from sqlite catalog queries', () => {
-    snapshot.prepare('BEGIN CONCURRENT').run()
-
-    expect(
-      live
-        .prepare("SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name")
-        .all()
-    ).toEqual([{ name: 'todo' }])
-  })
-
-  it('does not rewrite table names inside string literals during snapshots', () => {
-    live.exec('CREATE TABLE log (id TEXT PRIMARY KEY, table_name TEXT, _0_version TEXT)')
-    live.prepare('INSERT INTO log VALUES (?, ?, ?)').run('1', 'todo', '01')
-    live.prepare('INSERT INTO log VALUES (?, ?, ?)').run('2', '"todo"', '02')
-
-    snapshot.prepare('BEGIN CONCURRENT').run()
-
-    expect(
-      snapshot.prepare("SELECT table_name FROM log WHERE table_name = 'todo'").get()
-    ).toEqual({ table_name: 'todo' })
-    expect(
-      snapshot.prepare('SELECT table_name FROM log WHERE table_name = ?').get('"todo"')
-    ).toEqual({ table_name: '"todo"' })
-  })
-
-  it('cleans inactive snapshot tables when opening a database', () => {
-    mock.exec('CREATE TABLE _orez_snapshot_1_todo AS SELECT * FROM todo')
-    expect(
-      mock
-        .exec("SELECT name FROM sqlite_master WHERE name = '_orez_snapshot_1_todo'")
-        .toArray()
-    ).toEqual([{ name: '_orez_snapshot_1_todo' }])
-
-    const reopened = new Database(mock)
-    try {
-      expect(
-        mock
-          .exec("SELECT name FROM sqlite_master WHERE name = '_orez_snapshot_1_todo'")
-          .toArray()
-      ).toEqual([])
-    } finally {
-      reopened.close()
-    }
-  })
-
-  it('does not remove another open connection snapshot', () => {
-    snapshot.prepare('BEGIN CONCURRENT').run()
-    const snapshotTables = mock
-      .exec("SELECT name FROM sqlite_master WHERE name LIKE '_orez_snapshot_%'")
-      .toArray()
-    expect(snapshotTables).toHaveLength(1)
-
-    const other = new Database(mock)
-    try {
-      live
-        .prepare('UPDATE todo SET title = ?, _0_version = ? WHERE id = ?')
-        .run('new', '02', '1')
-
-      expect(snapshot.prepare('SELECT title FROM todo WHERE id = ?').get('1')).toEqual({
-        title: 'old',
-      })
-    } finally {
-      other.close()
-    }
-  })
-
-  it('persists BEGIN CONCURRENT writes for the zero-cache replica writer', () => {
-    const globalObject = globalThis as any
-    const previousRole = globalObject.__orez_zero_sqlite_role
-    globalObject.__orez_zero_sqlite_role = 'replica-writer'
-    let writer: Database
-    try {
-      writer = new Database(mock)
-    } finally {
-      if (previousRole === undefined) {
-        delete globalObject.__orez_zero_sqlite_role
-      } else {
-        globalObject.__orez_zero_sqlite_role = previousRole
-      }
-    }
-
-    writer.prepare('BEGIN CONCURRENT').run()
-    writer.prepare('INSERT INTO todo VALUES (?, ?, ?)').run('2', 'writer row', '02')
-    writer.prepare('COMMIT').run()
-
-    expect(live.prepare('SELECT title FROM todo WHERE id = ?').get('2')).toEqual({
-      title: 'writer row',
-    })
-    expect(
-      live
-        .prepare("SELECT name FROM sqlite_master WHERE name LIKE '_orez_snapshot_%'")
-        .all()
-    ).toEqual([])
-  })
-})
-
-describe('StatementRunner: zero-cache replicator pattern', () => {
-  let mock: SqlStorageLike & { _nativeDb: any }
-  let db: Database
-  let runner: StatementRunner
-
-  beforeEach(() => {
-    mock = createMockSqlStorage() as SqlStorageLike & { _nativeDb: any }
-    db = new Database(mock)
-    db.exec(`
-      CREATE TABLE issues (
-        issueID INTEGER PRIMARY KEY,
-        title TEXT,
-        _0_version TEXT
-      )
-    `)
-    runner = new StatementRunner(db)
-  })
-
-  afterEach(() => {
-    mock._nativeDb.close()
-  })
-
-  it('simulates zero-cache batch processing', () => {
-    // batch 1
-    runner.begin()
-    runner.run(
-      'INSERT INTO issues (issueID, title, _0_version) VALUES (?, ?, ?)',
-      1,
-      'bug',
-      '01'
-    )
-    runner.run(
-      'INSERT INTO issues (issueID, title, _0_version) VALUES (?, ?, ?)',
-      2,
-      'feat',
-      '01'
-    )
-    runner.commit()
-
-    expect(runner.all('SELECT * FROM issues ORDER BY issueID')).toEqual([
-      { issueID: 1, title: 'bug', _0_version: '01' },
-      { issueID: 2, title: 'feat', _0_version: '01' },
-    ])
-
-    // batch 2
-    runner.begin()
-    runner.run(
-      'INSERT OR REPLACE INTO issues (issueID, title, _0_version) VALUES (?, ?, ?)',
-      1,
-      'bug fix',
-      '02'
-    )
-    runner.commit()
-
-    expect(runner.get('SELECT title FROM issues WHERE issueID = ?', 1)).toEqual({
-      title: 'bug fix',
-    })
-  })
-
-  it('simulates rollback on conflict', () => {
-    runner.begin()
-    runner.run(
-      'INSERT INTO issues (issueID, title, _0_version) VALUES (?, ?, ?)',
-      1,
-      'ok',
-      '01'
-    )
-    runner.commit()
-
-    runner.begin()
-    try {
-      runner.run(
-        'INSERT INTO issues (issueID, title, _0_version) VALUES (?, ?, ?)',
-        1,
-        'dupe',
-        '02'
-      )
-    } catch {
-      runner.rollback()
-    }
-
-    // original row should still be there
-    expect(runner.get('SELECT title FROM issues WHERE issueID = ?', 1)).toEqual({
-      title: 'ok',
-    })
-  })
-})