@dotdo/postgres 0.1.0

package/src/worker/wal-replay.test.ts

@@ -0,0 +1,845 @@
+/**
+ * WAL Replay Tests
+ * Task: postgres-9te - WAL replay for point-in-time recovery
+ *
+ * Tests for WAL replay functionality including:
+ * - Reading WAL entries from R2 storage
+ * - Replaying operations to target timestamp or LSN
+ * - Partial replay for specific tables/schemas
+ * - Progress reporting and cancellation
+ * - Integrity verification
+ * - Error handling and rollback
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import {
+  WALReplayReader,
+  WALReplayer,
+  createWALReplayer,
+  createDryRunReplayer,
+  recoverToTimestamp,
+  recoverToLsn,
+  recoverTables,
+  type ReplayExecutor,
+  type ReplayConfig,
+  type ReplayProgressEvent,
+  type RecoveryFilter,
+} from './wal-replay'
+import type { SerializedWALEntry, WALEntry } from './wal'
+import type { R2WALStorage } from './wal-r2'
+
+// ============================================================================
+// Mock Helpers
+// ============================================================================
+
+/**
+ * Create sample WAL entries for testing
+ */
+function createSampleEntries(count: number, options: {
+  startLsn?: number
+  startTimestamp?: number
+  table?: string
+  schema?: string
+  transactionId?: string
+  operation?: 'INSERT' | 'UPDATE' | 'DELETE'
+} = {}): SerializedWALEntry[] {
+  const entries: SerializedWALEntry[] = []
+  const startLsn = options.startLsn ?? 1
+  const startTimestamp = options.startTimestamp ?? Date.now()
+  const table = options.table ?? 'users'
+  const schema = options.schema ?? 'public'
+  const operation = options.operation ?? 'INSERT'
+
+  for (let i = 0; i < count; i++) {
+    const lsn = startLsn + i
+    const entry: SerializedWALEntry = {
+      lsn: String(lsn),
+      operation,
+      schema,
+      table,
+      timestamp: startTimestamp + i * 1000,
+      transactionId: options.transactionId,
+      primaryKey: { id: lsn },
+    }
+
+    if (operation === 'INSERT' || operation === 'UPDATE') {
+      entry.newRow = { id: lsn, name: `User ${lsn}`, email: `user${lsn}@test.com` }
+    }
+    if (operation === 'UPDATE' || operation === 'DELETE') {
+      entry.oldRow = { id: lsn, name: `Old User ${lsn}`, email: `old${lsn}@test.com` }
+    }
+
+    entries.push(entry)
+  }
+  return entries
+}
+
+/**
+ * Create a mock R2WALStorage
+ */
+function createMockR2Storage(entries: SerializedWALEntry[] = []): R2WALStorage {
+  const storedEntries = [...entries]
+
+  return {
+    readEntries: vi.fn(async (fromLsn: bigint, limit = 1000): Promise<SerializedWALEntry[]> => {
+      return storedEntries
+        .filter((e) => BigInt(e.lsn) >= fromLsn)
+        .slice(0, limit)
+    }),
+    getLastLsn: vi.fn(async (): Promise<bigint | null> => {
+      if (storedEntries.length === 0) return null
+      return BigInt(storedEntries[storedEntries.length - 1].lsn)
+    }),
+    store: vi.fn(async (newEntries: SerializedWALEntry[]): Promise<void> => {
+      storedEntries.push(...newEntries)
+    }),
+    getStats: vi.fn(() => ({
+      segmentsUploaded: 1,
+      entriesStored: storedEntries.length,
+      bytesWritten: 1000,
+      bytesUncompressed: 2000,
+      failedUploads: 0,
+      retryCount: 0,
+      lastUploadAt: Date.now(),
+      lastFlushedLsn: storedEntries.length > 0 ? storedEntries[storedEntries.length - 1].lsn : null,
+    })),
+    listSegments: vi.fn(),
+    deleteSegmentsBefore: vi.fn(),
+    getCompressionRatio: vi.fn(() => 0.5),
+  } as unknown as R2WALStorage
+}
+
+/**
+ * Create a mock replay executor
+ */
+function createMockExecutor(): ReplayExecutor & {
+  executedQueries: Array<{ sql: string; params?: unknown[] }>
+  transactionState: 'none' | 'active' | 'committed' | 'rolled_back'
+} {
+  const executedQueries: Array<{ sql: string; params?: unknown[] }> = []
+  let transactionState: 'none' | 'active' | 'committed' | 'rolled_back' = 'none'
+
+  return {
+    executedQueries,
+    get transactionState() {
+      return transactionState
+    },
+    set transactionState(state) {
+      transactionState = state
+    },
+    query: vi.fn(async (sql: string, params?: unknown[]) => {
+      executedQueries.push({ sql, params })
+      return { rows: [], affectedRows: 1 }
+    }),
+    beginTransaction: vi.fn(async () => {
+      transactionState = 'active'
+    }),
+    commit: vi.fn(async () => {
+      transactionState = 'committed'
+    }),
+    rollback: vi.fn(async () => {
+      transactionState = 'rolled_back'
+    }),
+  }
+}
+
+// ============================================================================
+// WALReplayReader Tests
+// ============================================================================
+
+describe('WALReplayReader', () => {
+  describe('basic reading', () => {
+    it('should read entries from storage', async () => {
+      const entries = createSampleEntries(5)
+      const storage = createMockR2Storage(entries)
+      const reader = new WALReplayReader(storage)
+
+      const readEntries: WALEntry[] = []
+      for await (const entry of reader) {
+        readEntries.push(entry)
+      }
+
+      expect(readEntries.length).toBe(5)
+      expect(readEntries[0].lsn).toBe(1n)
+      expect(readEntries[4].lsn).toBe(5n)
+    })
+
+    it('should handle empty storage', async () => {
+      const storage = createMockR2Storage([])
+      const reader = new WALReplayReader(storage)
+
+      const readEntries: WALEntry[] = []
+      for await (const entry of reader) {
+        readEntries.push(entry)
+      }
+
+      expect(readEntries.length).toBe(0)
+    })
+
+    it('should start from specified LSN', async () => {
+      const entries = createSampleEntries(10)
+      const storage = createMockR2Storage(entries)
+      const reader = new WALReplayReader(storage, { fromLsn: 5n })
+
+      const readEntries: WALEntry[] = []
+      for await (const entry of reader) {
+        readEntries.push(entry)
+      }
+
+      expect(readEntries.every((e) => e.lsn >= 5n)).toBe(true)
+    })
+
+    it('should stop at specified LSN', async () => {
+      const entries = createSampleEntries(10)
+      const storage = createMockR2Storage(entries)
+      const reader = new WALReplayReader(storage, { toLsn: 6n })
+
+      const readEntries: WALEntry[] = []
+      for await (const entry of reader) {
+        readEntries.push(entry)
+      }
+
+      expect(readEntries.every((e) => e.lsn < 6n)).toBe(true)
+    })
+
+    it('should stop at specified timestamp', async () => {
+      const baseTime = Date.now()
+      const entries = createSampleEntries(10, { startTimestamp: baseTime })
+      const storage = createMockR2Storage(entries)
+      const targetTime = baseTime + 5000
+
+      const reader = new WALReplayReader(storage, { toTimestamp: targetTime })
+
+      const readEntries: WALEntry[] = []
+      for await (const entry of reader) {
+        readEntries.push(entry)
+      }
+
+      expect(readEntries.every((e) => e.timestamp < targetTime)).toBe(true)
+    })
+  })
+
+  describe('batching', () => {
+    it('should respect batch size', async () => {
+      const entries = createSampleEntries(25)
+      const storage = createMockR2Storage(entries)
+      const reader = new WALReplayReader(storage, { batchSize: 10 })
+
+      const readEntries: WALEntry[] = []
+      for await (const entry of reader) {
+        readEntries.push(entry)
+      }
+
+      // Should have made multiple calls to readEntries
+      expect(storage.readEntries).toHaveBeenCalled()
+      expect(readEntries.length).toBe(25)
+    })
+
+    it('should track total entries read', async () => {
+      const entries = createSampleEntries(15)
+      const storage = createMockR2Storage(entries)
+      const reader = new WALReplayReader(storage)
+
+      for await (const _entry of reader) {
+        // Just iterate
+      }
+
+      expect(reader.getTotalRead()).toBe(15)
+    })
+  })
+
+  describe('next() method', () => {
+    it('should return entries one at a time', async () => {
+      const entries = createSampleEntries(3)
+      const storage = createMockR2Storage(entries)
+      const reader = new WALReplayReader(storage)
+
+      const entry1 = await reader.next()
+      const entry2 = await reader.next()
+      const entry3 = await reader.next()
+      const entry4 = await reader.next()
+
+      expect(entry1?.lsn).toBe(1n)
+      expect(entry2?.lsn).toBe(2n)
+      expect(entry3?.lsn).toBe(3n)
+      expect(entry4).toBeNull()
+    })
+
+    it('should report exhausted state', async () => {
+      const entries = createSampleEntries(2)
+      const storage = createMockR2Storage(entries)
+      const reader = new WALReplayReader(storage)
+
+      expect(reader.isExhausted()).toBe(false)
+
+      await reader.next()
+      await reader.next()
+      await reader.next() // null
+
+      expect(reader.isExhausted()).toBe(true)
+    })
+  })
+})
+
+// ============================================================================
+// WALReplayer Tests
+// ============================================================================
+
+describe('WALReplayer', () => {
+  let executor: ReturnType<typeof createMockExecutor>
+  let storage: R2WALStorage
+
+  beforeEach(() => {
+    executor = createMockExecutor()
+  })
+
+  describe('basic replay', () => {
+    it('should replay all entries to target LSN', async () => {
+      const entries = createSampleEntries(5)
+      storage = createMockR2Storage(entries)
+
+      const replayer = createWALReplayer(executor, {
+        storage,
+        target: { lsn: 10n },
+        verifyIntegrity: false, // Disable to get accurate query count
+      })
+
+      const result = await replayer.replay()
+
+      expect(result.success).toBe(true)
+      expect(result.stats.entriesReplayed).toBe(5)
+      expect(executor.executedQueries.length).toBe(5)
+    })
+
+    it('should replay entries to target timestamp', async () => {
+      const baseTime = Date.now()
+      const entries = createSampleEntries(10, { startTimestamp: baseTime })
+      storage = createMockR2Storage(entries)
+
+      const targetTime = baseTime + 5000
+
+      const replayer = createWALReplayer(executor, {
+        storage,
+        target: { timestamp: targetTime },
+      })
+
+      const result = await replayer.replay()
+
+      expect(result.success).toBe(true)
+      expect(result.stats.entriesReplayed).toBeLessThan(10)
+    })
+
+    it('should handle empty storage', async () => {
+      storage = createMockR2Storage([])
+
+      const replayer = createWALReplayer(executor, {
+        storage,
+        target: { lsn: 100n },
+      })
+
+      const result = await replayer.replay()
+
+      expect(result.success).toBe(true)
+      expect(result.stats.entriesReplayed).toBe(0)
+    })
+
+    it('should generate correct SQL for INSERT', async () => {
+      const entries = createSampleEntries(1, { operation: 'INSERT' })
+      storage = createMockR2Storage(entries)
+
+      const replayer = createWALReplayer(executor, {
+        storage,
+        target: { lsn: 10n },
+        verifyIntegrity: false, // Disable to get accurate query count
+      })
+
+      await replayer.replay()
+
+      expect(executor.executedQueries.length).toBe(1)
+      expect(executor.executedQueries[0].sql).toMatch(/INSERT INTO/)
+    })
+
+    it('should generate correct SQL for UPDATE', async () => {
+      const entries = createSampleEntries(1, { operation: 'UPDATE' })
+      storage = createMockR2Storage(entries)
+
+      const replayer = createWALReplayer(executor, {
+        storage,
+        target: { lsn: 10n },
+        verifyIntegrity: false, // Disable to get accurate query count
+      })
+
+      await replayer.replay()
+
+      expect(executor.executedQueries.length).toBe(1)
+      expect(executor.executedQueries[0].sql).toMatch(/UPDATE/)
+    })
+
+    it('should generate correct SQL for DELETE', async () => {
+      const entries = createSampleEntries(1, { operation: 'DELETE' })
+      storage = createMockR2Storage(entries)
+
+      const replayer = createWALReplayer(executor, {
+        storage,
+        target: { lsn: 10n },
+        verifyIntegrity: false, // Disable to get accurate query count
+      })
+
+      await replayer.replay()
+
+      expect(executor.executedQueries.length).toBe(1)
+      expect(executor.executedQueries[0].sql).toMatch(/DELETE FROM/)
+    })
+  })
+
+  describe('transaction handling', () => {
+    it('should use transactions when supported', async () => {
+      const entries = createSampleEntries(3)
+      storage = createMockR2Storage(entries)
+
+      const replayer = createWALReplayer(executor, {
+        storage,
+        target: { lsn: 10n },
+      })
+
+      await replayer.replay()
+
+      expect(executor.beginTransaction).toHaveBeenCalled()
+      expect(executor.commit).toHaveBeenCalled()
+      expect(executor.transactionState).toBe('committed')
+    })
+
+    it('should rollback on error', async () => {
+      const entries = createSampleEntries(3)
+      storage = createMockR2Storage(entries)
+
+      // Make the second query fail
+      let queryCount = 0
+      executor.query = vi.fn(async () => {
+        queryCount++
+        if (queryCount === 2) {
+          throw new Error('Query failed')
+        }
+        return { rows: [], affectedRows: 1 }
+      })
+
+      const replayer = createWALReplayer(executor, {
+        storage,
+        target: { lsn: 10n },
+      })
+
+      const result = await replayer.replay()
+
+      expect(result.success).toBe(false)
+      expect(executor.rollback).toHaveBeenCalled()
+      expect(result.rolledBack).toBe(true)
+    })
+  })
+
+  describe('filtering', () => {
+    it('should filter by table', async () => {
+      const userEntries = createSampleEntries(3, { table: 'users' })
+      const orderEntries = createSampleEntries(3, { table: 'orders', startLsn: 4 })
+      storage = createMockR2Storage([...userEntries, ...orderEntries])
+
+      const replayer = createWALReplayer(executor, {
+        storage,
+        target: { lsn: 100n },
+        filter: { mode: 'table', tables: ['users'] },
+      })
+
+      const result = await replayer.replay()
+
+      expect(result.success).toBe(true)
+      expect(result.stats.entriesReplayed).toBe(3)
+      expect(result.stats.entriesSkipped).toBe(3)
+    })
+
+    it('should filter by schema', async () => {
+      const publicEntries = createSampleEntries(3, { schema: 'public' })
+      const privateEntries = createSampleEntries(3, { schema: 'private', startLsn: 4 })
+      storage = createMockR2Storage([...publicEntries, ...privateEntries])
+
+      const replayer = createWALReplayer(executor, {
+        storage,
+        target: { lsn: 100n },
+        filter: { mode: 'schema', schemas: ['private'] },
+      })
+
+      const result = await replayer.replay()
+
+      expect(result.success).toBe(true)
+      expect(result.stats.entriesReplayed).toBe(3)
+      expect(result.stats.entriesSkipped).toBe(3)
+    })
+
+    it('should filter by operation', async () => {
+      const insertEntries = createSampleEntries(3, { operation: 'INSERT' })
+      const updateEntries = createSampleEntries(3, { operation: 'UPDATE', startLsn: 4 })
+      storage = createMockR2Storage([...insertEntries, ...updateEntries])
+
+      const replayer = createWALReplayer(executor, {
+        storage,
+        target: { lsn: 100n },
+        filter: { mode: 'full', operations: ['INSERT'] },
+      })
+
+      const result = await replayer.replay()
+
+      expect(result.success).toBe(true)
+      expect(result.stats.entriesReplayed).toBe(3)
+      expect(result.stats.entriesSkipped).toBe(3)
+    })
+
+    it('should filter by transaction', async () => {
+      const tx1Entries = createSampleEntries(3, { transactionId: 'tx-1' })
+      const tx2Entries = createSampleEntries(3, { transactionId: 'tx-2', startLsn: 4 })
+      storage = createMockR2Storage([...tx1Entries, ...tx2Entries])
+
+      const replayer = createWALReplayer(executor, {
+        storage,
+        target: { lsn: 100n },
+        filter: { mode: 'transaction', transactionIds: ['tx-1'] },
+      })
+
+      const result = await replayer.replay()
+
+      expect(result.success).toBe(true)
+      expect(result.stats.entriesReplayed).toBe(3)
+      expect(result.stats.entriesSkipped).toBe(3)
+    })
+  })
+
+  describe('dry run', () => {
+    it('should not execute queries in dry run mode', async () => {
+      const entries = createSampleEntries(5)
+      storage = createMockR2Storage(entries)
+
+      const replayer = createDryRunReplayer(executor, {
+        storage,
+        target: { lsn: 10n },
+      })
+
+      const result = await replayer.replay()
+
+      expect(result.success).toBe(true)
+      expect(executor.executedQueries.length).toBe(0)
+      expect(executor.beginTransaction).not.toHaveBeenCalled()
+    })
+
+    it('should still track statistics in dry run', async () => {
+      const entries = createSampleEntries(5)
+      storage = createMockR2Storage(entries)
+
+      const replayer = createDryRunReplayer(executor, {
+        storage,
+        target: { lsn: 10n },
+      })
+
+      const result = await replayer.replay()
+
+      expect(result.stats.entriesReplayed).toBe(5)
+    })
+  })
+
+  describe('progress reporting', () => {
+    it('should call progress callback', async () => {
+      const entries = createSampleEntries(5)
+      storage = createMockR2Storage(entries)
+
+      const progressEvents: ReplayProgressEvent[] = []
+
+      const replayer = createWALReplayer(executor, {
+        storage,
+        target: { lsn: 10n },
+        onProgress: (event) => progressEvents.push(event),
+        progressIntervalMs: 0, // Report every event
+      })
+
+      await replayer.replay()
+
+      expect(progressEvents.length).toBeGreaterThan(0)
+      expect(progressEvents[0].phase).toBe('starting')
+      expect(progressEvents[progressEvents.length - 1].phase).toBe('completed')
+    })
+
+    it('should report correct statistics in progress', async () => {
+      const entries = createSampleEntries(5)
+      storage = createMockR2Storage(entries)
+
+      let lastEvent: ReplayProgressEvent | null = null
+
+      const replayer = createWALReplayer(executor, {
+        storage,
+        target: { lsn: 10n },
+        onProgress: (event) => { lastEvent = event },
+        progressIntervalMs: 0,
+      })
+
+      await replayer.replay()
+
+      expect(lastEvent).not.toBeNull()
+      expect(lastEvent!.entriesReplayed).toBe(5)
+      expect(lastEvent!.phase).toBe('completed')
+    })
+  })
+
+  describe('error handling', () => {
+    it('should continue on error when configured', async () => {
+      const entries = createSampleEntries(5)
+      storage = createMockR2Storage(entries)
+
+      let queryCount = 0
+      executor.query = vi.fn(async () => {
+        queryCount++
+        if (queryCount === 3) {
+          throw new Error('Query failed')
+        }
+        return { rows: [], affectedRows: 1 }
+      })
+
+      const replayer = createWALReplayer(executor, {
+        storage,
+        target: { lsn: 10n },
+        continueOnError: true,
+      })
+
+      const result = await replayer.replay()
+
+      expect(result.success).toBe(true) // Continues despite error
+      expect(result.stats.entriesFailed).toBe(1)
+      expect(result.stats.entriesReplayed).toBe(4)
+      expect(result.failedEntries).toHaveLength(1)
+    })
+
+    it('should stop on error by default', async () => {
+      const entries = createSampleEntries(5)
+      storage = createMockR2Storage(entries)
+
+      let queryCount = 0
+      executor.query = vi.fn(async () => {
+        queryCount++
+        if (queryCount === 3) {
+          throw new Error('Query failed')
+        }
+        return { rows: [], affectedRows: 1 }
+      })
+
+      const replayer = createWALReplayer(executor, {
+        storage,
+        target: { lsn: 10n },
+        continueOnError: false,
+      })
+
+      const result = await replayer.replay()
+
+      expect(result.success).toBe(false)
+      expect(result.error).toContain('Query failed')
+    })
+  })
+
+  describe('abort', () => {
+    it('should support aborting replay', async () => {
+      const entries = createSampleEntries(10)
+      storage = createMockR2Storage(entries)
+
+      const replayer = createWALReplayer(executor, {
+        storage,
+        target: { lsn: 100n },
+      })
+
+      // Abort after first query
+      executor.query = vi.fn(async () => {
+        replayer.abort()
+        return { rows: [], affectedRows: 1 }
+      })
+
+      const result = await replayer.replay()
+
+      expect(result.success).toBe(false)
+      expect(result.error).toContain('aborted')
+      expect(replayer.isAborted()).toBe(true)
+    })
+  })
+
+  describe('statistics', () => {
+    it('should track replay statistics', async () => {
+      const entries = createSampleEntries(10)
+      storage = createMockR2Storage(entries)
+
+      const replayer = createWALReplayer(executor, {
+        storage,
+        target: { lsn: 100n },
+      })
+
+      const result = await replayer.replay()
+
+      expect(result.stats.entriesRead).toBe(10)
+      expect(result.stats.entriesReplayed).toBe(10)
+      expect(result.stats.startLsn).toBe(1n)
+      expect(result.stats.endLsn).toBe(10n)
+      expect(result.stats.durationMs).toBeGreaterThan(0)
+      expect(result.stats.throughputEntriesPerSec).toBeGreaterThan(0)
+    })
+
+    it('should track timestamps in statistics', async () => {
+      const baseTime = Date.now()
+      const entries = createSampleEntries(5, { startTimestamp: baseTime })
+      storage = createMockR2Storage(entries)
+
+      const replayer = createWALReplayer(executor, {
+        storage,
+        target: { lsn: 100n },
+      })
+
+      const result = await replayer.replay()
+
+      expect(result.stats.startTimestamp).toBe(baseTime)
+      expect(result.stats.endTimestamp).toBe(baseTime + 4000)
+    })
+  })
+})
+
+// ============================================================================
+// Helper Function Tests
+// ============================================================================
+
+describe('Helper Functions', () => {
+  let executor: ReturnType<typeof createMockExecutor>
+
+  beforeEach(() => {
+    executor = createMockExecutor()
+  })
+
+  describe('recoverToTimestamp', () => {
+    it('should recover to a specific timestamp', async () => {
+      const baseTime = Date.now()
+      const entries = createSampleEntries(10, { startTimestamp: baseTime })
+      const storage = createMockR2Storage(entries)
+
+      const result = await recoverToTimestamp(executor, storage, baseTime + 5000)
+
+      expect(result.success).toBe(true)
+      expect(result.stats.entriesReplayed).toBeLessThan(10)
+    })
+  })
+
+  describe('recoverToLsn', () => {
+    it('should recover to a specific LSN', async () => {
+      const entries = createSampleEntries(10)
+      const storage = createMockR2Storage(entries)
+
+      const result = await recoverToLsn(executor, storage, 6n)
+
+      expect(result.success).toBe(true)
+      expect(result.stats.entriesReplayed).toBe(5)
+    })
+  })
+
+  describe('recoverTables', () => {
+    it('should recover specific tables', async () => {
+      const userEntries = createSampleEntries(3, { table: 'users' })
+      const orderEntries = createSampleEntries(3, { table: 'orders', startLsn: 4 })
+      const storage = createMockR2Storage([...userEntries, ...orderEntries])
+
+      const result = await recoverTables(executor, storage, ['users'], {
+        target: { lsn: 100n },
+      })
+
+      expect(result.success).toBe(true)
+      expect(result.stats.entriesReplayed).toBe(3)
+      expect(result.stats.entriesSkipped).toBe(3)
+    })
+
+    it('should recover multiple tables', async () => {
+      const userEntries = createSampleEntries(3, { table: 'users' })
+      const orderEntries = createSampleEntries(3, { table: 'orders', startLsn: 4 })
+      const productEntries = createSampleEntries(3, { table: 'products', startLsn: 7 })
+      const storage = createMockR2Storage([...userEntries, ...orderEntries, ...productEntries])
+
+      const result = await recoverTables(executor, storage, ['users', 'orders'], {
+        target: { lsn: 100n },
+      })
+
+      expect(result.success).toBe(true)
+      expect(result.stats.entriesReplayed).toBe(6)
+      expect(result.stats.entriesSkipped).toBe(3)
+    })
+  })
+})
+
+// ============================================================================
+// Integration Tests
+// ============================================================================
+
+describe('Integration Tests', () => {
+  let executor: ReturnType<typeof createMockExecutor>
+
+  beforeEach(() => {
+    executor = createMockExecutor()
+  })
+
+  it('should handle mixed operation types', async () => {
+    const insertEntries = createSampleEntries(2, { operation: 'INSERT', startLsn: 1 })
+    const updateEntries = createSampleEntries(2, { operation: 'UPDATE', startLsn: 3 })
+    const deleteEntries = createSampleEntries(2, { operation: 'DELETE', startLsn: 5 })
+    const storage = createMockR2Storage([...insertEntries, ...updateEntries, ...deleteEntries])
+
+    const replayer = createWALReplayer(executor, {
+      storage,
+      target: { lsn: 100n },
+    })
+
+    const result = await replayer.replay()
+
+    expect(result.success).toBe(true)
+    expect(result.stats.entriesReplayed).toBe(6)
+
+    // Verify correct SQL was generated for each type
+    expect(executor.executedQueries.filter((q) => q.sql.includes('INSERT'))).toHaveLength(2)
+    expect(executor.executedQueries.filter((q) => q.sql.includes('UPDATE'))).toHaveLength(2)
+    expect(executor.executedQueries.filter((q) => q.sql.includes('DELETE'))).toHaveLength(2)
+  })
+
+  it('should handle large replay', async () => {
+    const entries = createSampleEntries(1000)
+    const storage = createMockR2Storage(entries)
+
+    const replayer = createWALReplayer(executor, {
+      storage,
+      target: { lsn: 2000n },
+      batchSize: 100,
+    })
+
+    const result = await replayer.replay()
+
+    expect(result.success).toBe(true)
+    expect(result.stats.entriesReplayed).toBe(1000)
+    expect(result.stats.throughputEntriesPerSec).toBeGreaterThan(0)
+  })
+
+  it('should handle replay with all filters combined', async () => {
+    const entries = [
+      ...createSampleEntries(2, { table: 'users', operation: 'INSERT', schema: 'public', transactionId: 'tx-1' }),
+      ...createSampleEntries(2, { table: 'users', operation: 'UPDATE', schema: 'public', transactionId: 'tx-2', startLsn: 3 }),
+      ...createSampleEntries(2, { table: 'orders', operation: 'INSERT', schema: 'public', transactionId: 'tx-1', startLsn: 5 }),
+      ...createSampleEntries(2, { table: 'users', operation: 'INSERT', schema: 'private', transactionId: 'tx-1', startLsn: 7 }),
+    ]
+    const storage = createMockR2Storage(entries)
+
+    const replayer = createWALReplayer(executor, {
+      storage,
+      target: { lsn: 100n },
+      filter: {
+        mode: 'table',
+        tables: ['users'],
+        operations: ['INSERT'],
+      },
+    })
+
+    const result = await replayer.replay()
+
+    expect(result.success).toBe(true)
+    // Should only replay: users + INSERT = 2 from first batch + 2 from private schema = 4
+    expect(result.stats.entriesReplayed).toBe(4)
+  })
+})