@dotdo/postgres 0.1.0 → 0.1.2

package/src/__tests__/backup.test.ts

@@ -0,0 +1,944 @@
+/**
+ * Tests for Automated Backup to R2
+ * Task: postgres-7yr6.1 - Production readiness: Automated backup to R2
+ *
+ * RED phase TDD - These tests define the expected API surface for:
+ * - Scheduled backup creation
+ * - Incremental backup support
+ * - Backup manifest management
+ * - Restore from backup
+ * - Backup lifecycle (retention, pruning)
+ * - Error handling and edge cases
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+// These imports define the expected API surface - they will fail until implemented
+import {
+  BackupManager,
+  createBackupManager,
+  type BackupConfig,
+  type BackupManifest,
+  type BackupEntry,
+  type BackupSchedule,
+  type BackupResult,
+  type RestoreResult,
+  type BackupStats,
+  type IncrementalBackupState,
+  type BackupRetentionPolicy,
+} from '../backup/backup-manager'
+
+// =============================================================================
+// Mock Setup
+// =============================================================================
+
+const createMockR2Bucket = () => ({
+  get: vi.fn(),
+  put: vi.fn().mockResolvedValue(undefined),
+  delete: vi.fn().mockResolvedValue(undefined),
+  list: vi.fn().mockResolvedValue({ objects: [], truncated: false }),
+  head: vi.fn(),
+})
+
+const createMockDOStorage = () => ({
+  get: vi.fn(),
+  put: vi.fn().mockResolvedValue(undefined),
+  delete: vi.fn().mockResolvedValue(undefined),
+  list: vi.fn().mockResolvedValue(new Map()),
+})
+
+const createMockPGLite = () => ({
+  query: vi.fn().mockResolvedValue({ rows: [] }),
+  exec: vi.fn().mockResolvedValue(undefined),
+  close: vi.fn().mockResolvedValue(undefined),
+})
+
+// =============================================================================
+// Tests: BackupManager Creation
+// =============================================================================
+
+describe('BackupManager', () => {
+  let mockBucket: ReturnType<typeof createMockR2Bucket>
+  let mockStorage: ReturnType<typeof createMockDOStorage>
+  let mockPGLite: ReturnType<typeof createMockPGLite>
+
+  beforeEach(() => {
+    vi.useFakeTimers()
+    mockBucket = createMockR2Bucket()
+    mockStorage = createMockDOStorage()
+    mockPGLite = createMockPGLite()
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+    vi.clearAllMocks()
+  })
+
+  describe('createBackupManager()', () => {
+    it('should create a BackupManager instance with minimal config', () => {
+      const manager = createBackupManager({
+        bucket: mockBucket as unknown as R2Bucket,
+        doId: 'test-do-123',
+        prefix: 'backups/',
+      })
+      expect(manager).toBeInstanceOf(BackupManager)
+    })
+
+    it('should create a BackupManager with full configuration', () => {
+      const config: BackupConfig = {
+        bucket: mockBucket as unknown as R2Bucket,
+        doId: 'test-do-123',
+        prefix: 'backups/',
+        schedule: {
+          intervalMs: 3600000, // 1 hour
+          type: 'incremental',
+          fullBackupIntervalMs: 86400000, // 24 hours
+        },
+        retention: {
+          maxBackups: 30,
+          maxAgeDays: 7,
+          keepMinFullBackups: 3,
+        },
+        compression: true,
+        checksumAlgorithm: 'sha-256',
+        maxConcurrentUploads: 3,
+      }
+      const manager = createBackupManager(config)
+      expect(manager).toBeInstanceOf(BackupManager)
+    })
+
+    it('should throw if bucket is not provided', () => {
+      expect(() =>
+        createBackupManager({
+          bucket: undefined as unknown as R2Bucket,
+          doId: 'test-do-123',
+          prefix: 'backups/',
+        })
+      ).toThrow()
+    })
+
+    it('should throw if doId is empty', () => {
+      expect(() =>
+        createBackupManager({
+          bucket: mockBucket as unknown as R2Bucket,
+          doId: '',
+          prefix: 'backups/',
+        })
+      ).toThrow()
+    })
+  })
+
+  // ===========================================================================
+  // Tests: Full Backup
+  // ===========================================================================
+
+  describe('Full Backup', () => {
+    let manager: InstanceType<typeof BackupManager>
+
+    beforeEach(() => {
+      manager = createBackupManager({
+        bucket: mockBucket as unknown as R2Bucket,
+        doId: 'test-do-123',
+        prefix: 'backups/',
+      })
+    })
+
+    it('should create a full backup of the database', async () => {
+      mockPGLite.query.mockResolvedValueOnce({
+        rows: [{ datname: 'test' }],
+      })
+
+      const result = await manager.createFullBackup(mockPGLite as any)
+
+      expect(result.success).toBe(true)
+      expect(result.type).toBe('full')
+      expect(result.backupId).toBeDefined()
+      expect(result.sizeBytes).toBeGreaterThan(0)
+      expect(result.timestamp).toBeDefined()
+    })
+
+    it('should store backup data in R2 with correct key structure', async () => {
+      await manager.createFullBackup(mockPGLite as any)
+
+      expect(mockBucket.put).toHaveBeenCalled()
+      const putCall = mockBucket.put.mock.calls[0]
+      expect(putCall[0]).toMatch(/^backups\/test-do-123\/full\//)
+    })
+
+    it('should include checksum in backup metadata', async () => {
+      const result = await manager.createFullBackup(mockPGLite as any)
+
+      expect(result.checksum).toBeDefined()
+      expect(result.checksumAlgorithm).toBe('sha-256')
+    })
+
+    it('should compress backup data when compression is enabled', async () => {
+      const compressedManager = createBackupManager({
+        bucket: mockBucket as unknown as R2Bucket,
+        doId: 'test-do-123',
+        prefix: 'backups/',
+        compression: true,
+      })
+
+      const result = await compressedManager.createFullBackup(mockPGLite as any)
+
+      expect(result.compressed).toBe(true)
+      expect(result.uncompressedSizeBytes).toBeGreaterThanOrEqual(result.sizeBytes)
+    })
+
+    it('should handle backup failure gracefully', async () => {
+      mockBucket.put.mockRejectedValueOnce(new Error('R2 write failed'))
+
+      const result = await manager.createFullBackup(mockPGLite as any)
+
+      expect(result.success).toBe(false)
+      expect(result.error).toContain('R2 write failed')
+    })
+
+    it('should capture all tables in the full backup', async () => {
+      mockPGLite.query
+        .mockResolvedValueOnce({
+          rows: [
+            { tablename: 'users', schemaname: 'public' },
+            { tablename: 'orders', schemaname: 'public' },
+            { tablename: 'products', schemaname: 'public' },
+          ],
+        })
+
+      const result = await manager.createFullBackup(mockPGLite as any)
+
+      expect(result.tables).toContain('users')
+      expect(result.tables).toContain('orders')
+      expect(result.tables).toContain('products')
+    })
+
+    it('should generate a unique backup ID for each backup', async () => {
+      const result1 = await manager.createFullBackup(mockPGLite as any)
+      const result2 = await manager.createFullBackup(mockPGLite as any)
+
+      expect(result1.backupId).not.toBe(result2.backupId)
+    })
+
+    it('should record backup duration', async () => {
+      const result = await manager.createFullBackup(mockPGLite as any)
+
+      expect(result.durationMs).toBeDefined()
+      expect(result.durationMs).toBeGreaterThanOrEqual(0)
+    })
+  })
+
+  // ===========================================================================
+  // Tests: Incremental Backup
+  // ===========================================================================
+
+  describe('Incremental Backup', () => {
+    let manager: InstanceType<typeof BackupManager>
+
+    beforeEach(() => {
+      manager = createBackupManager({
+        bucket: mockBucket as unknown as R2Bucket,
+        doId: 'test-do-123',
+        prefix: 'backups/',
+      })
+    })
+
+    it('should create an incremental backup based on last full backup', async () => {
+      // First create a full backup
+      await manager.createFullBackup(mockPGLite as any)
+
+      // Then create an incremental backup
+      const result = await manager.createIncrementalBackup(mockPGLite as any)
+
+      expect(result.success).toBe(true)
+      expect(result.type).toBe('incremental')
+      expect(result.baseBackupId).toBeDefined()
+    })
+
+    it('should only include changed data since last backup', async () => {
+      await manager.createFullBackup(mockPGLite as any)
+
+      // Simulate some changes
+      mockPGLite.query.mockResolvedValueOnce({
+        rows: [{ lsn: '0/1000' }], // Current WAL position
+      })
+
+      const result = await manager.createIncrementalBackup(mockPGLite as any)
+
+      expect(result.sizeBytes).toBeDefined()
+      // Incremental should be smaller than full backup
+      expect(result.changedPages).toBeDefined()
+    })
+
+    it('should fail if no base backup exists', async () => {
+      const result = await manager.createIncrementalBackup(mockPGLite as any)
+
+      expect(result.success).toBe(false)
+      expect(result.error).toContain('No base backup found')
+    })
+
+    it('should track incremental state between backups', async () => {
+      await manager.createFullBackup(mockPGLite as any)
+
+      const state = await manager.getIncrementalState()
+
+      expect(state).toBeDefined()
+      expect(state.lastBackupLsn).toBeDefined()
+      expect(state.lastBackupTimestamp).toBeDefined()
+      expect(state.baseBackupId).toBeDefined()
+    })
+
+    it('should chain incremental backups correctly', async () => {
+      await manager.createFullBackup(mockPGLite as any)
+
+      const inc1 = await manager.createIncrementalBackup(mockPGLite as any)
+      const inc2 = await manager.createIncrementalBackup(mockPGLite as any)
+
+      expect(inc1.backupId).not.toBe(inc2.backupId)
+      expect(inc2.baseBackupId).toBe(inc1.backupId)
+    })
+
+    it('should store incremental backup with correct key structure', async () => {
+      await manager.createFullBackup(mockPGLite as any)
+      await manager.createIncrementalBackup(mockPGLite as any)
+
+      const putCalls = mockBucket.put.mock.calls
+      const incrementalCall = putCalls.find((call: any) =>
+        (call[0] as string).includes('incremental')
+      )
+      expect(incrementalCall).toBeDefined()
+      expect(incrementalCall![0]).toMatch(/^backups\/test-do-123\/incremental\//)
+    })
+
+    it('should include parent chain in incremental backup metadata', async () => {
+      await manager.createFullBackup(mockPGLite as any)
+      const inc1 = await manager.createIncrementalBackup(mockPGLite as any)
+      const inc2 = await manager.createIncrementalBackup(mockPGLite as any)
+
+      expect(inc2.parentChain).toBeDefined()
+      expect(inc2.parentChain!.length).toBeGreaterThanOrEqual(2)
+    })
+  })
+
+  // ===========================================================================
+  // Tests: Backup Manifest
+  // ===========================================================================
+
+  describe('Backup Manifest', () => {
+    let manager: InstanceType<typeof BackupManager>
+
+    beforeEach(() => {
+      manager = createBackupManager({
+        bucket: mockBucket as unknown as R2Bucket,
+        doId: 'test-do-123',
+        prefix: 'backups/',
+      })
+    })
+
+    it('should create and update the backup manifest after each backup', async () => {
+      await manager.createFullBackup(mockPGLite as any)
+
+      const manifest = await manager.getManifest()
+
+      expect(manifest).toBeDefined()
+      expect(manifest.doId).toBe('test-do-123')
+      expect(manifest.entries.length).toBe(1)
+      expect(manifest.version).toBeDefined()
+    })
+
+    it('should store manifest in R2 at a known location', async () => {
+      await manager.createFullBackup(mockPGLite as any)
+
+      const manifestKey = 'backups/test-do-123/manifest.json'
+      const putCalls = mockBucket.put.mock.calls
+      const manifestPut = putCalls.find((call: any) =>
+        (call[0] as string).includes('manifest.json')
+      )
+      expect(manifestPut).toBeDefined()
+    })
+
+    it('should include backup chain information in manifest', async () => {
+      await manager.createFullBackup(mockPGLite as any)
+      await manager.createIncrementalBackup(mockPGLite as any)
+      await manager.createIncrementalBackup(mockPGLite as any)
+
+      const manifest = await manager.getManifest()
+
+      expect(manifest.entries.length).toBe(3)
+      expect(manifest.entries[0].type).toBe('full')
+      expect(manifest.entries[1].type).toBe('incremental')
+      expect(manifest.entries[2].type).toBe('incremental')
+    })
+
+    it('should track total backup size in manifest', async () => {
+      await manager.createFullBackup(mockPGLite as any)
+      await manager.createIncrementalBackup(mockPGLite as any)
+
+      const manifest = await manager.getManifest()
+
+      expect(manifest.totalSizeBytes).toBeGreaterThan(0)
+    })
+
+    it('should validate manifest integrity', async () => {
+      await manager.createFullBackup(mockPGLite as any)
+
+      const isValid = await manager.validateManifest()
+
+      expect(isValid).toBe(true)
+    })
+
+    it('should detect corrupted manifest', async () => {
+      // Simulate corrupted manifest in R2
+      mockBucket.get.mockResolvedValueOnce({
+        text: () => Promise.resolve('invalid json {{{'),
+        bytes: () => Promise.resolve(new Uint8Array()),
+      })
+
+      const isValid = await manager.validateManifest()
+
+      expect(isValid).toBe(false)
+    })
+
+    it('should list all backups from manifest', async () => {
+      await manager.createFullBackup(mockPGLite as any)
+      await manager.createIncrementalBackup(mockPGLite as any)
+
+      const backups = await manager.listBackups()
+
+      expect(backups.length).toBe(2)
+      expect(backups[0].backupId).toBeDefined()
+      expect(backups[0].timestamp).toBeDefined()
+      expect(backups[0].type).toBeDefined()
+      expect(backups[0].sizeBytes).toBeDefined()
+    })
+
+    it('should include manifest checksum for integrity verification', async () => {
+      await manager.createFullBackup(mockPGLite as any)
+
+      const manifest = await manager.getManifest()
+
+      expect(manifest.checksum).toBeDefined()
+    })
+  })
+
+  // ===========================================================================
+  // Tests: Restore from Backup
+  // ===========================================================================
+
+  describe('Restore from Backup', () => {
+    let manager: InstanceType<typeof BackupManager>
+
+    beforeEach(() => {
+      manager = createBackupManager({
+        bucket: mockBucket as unknown as R2Bucket,
+        doId: 'test-do-123',
+        prefix: 'backups/',
+      })
+    })
+
+    it('should restore from a full backup by ID', async () => {
+      const backup = await manager.createFullBackup(mockPGLite as any)
+
+      mockBucket.get.mockResolvedValueOnce({
+        bytes: () => Promise.resolve(new Uint8Array([1, 2, 3])),
+        text: () => Promise.resolve(''),
+      })
+
+      const result = await manager.restoreFromBackup(
+        backup.backupId,
+        mockPGLite as any
+      )
+
+      expect(result.success).toBe(true)
+      expect(result.restoredFromBackupId).toBe(backup.backupId)
+      expect(result.tablesRestored).toBeDefined()
+    })
+
+    it('should restore from latest backup when no ID specified', async () => {
+      await manager.createFullBackup(mockPGLite as any)
+      const latest = await manager.createFullBackup(mockPGLite as any)
+
+      mockBucket.get.mockResolvedValueOnce({
+        bytes: () => Promise.resolve(new Uint8Array([1, 2, 3])),
+        text: () => Promise.resolve(''),
+      })
+
+      const result = await manager.restoreFromLatest(mockPGLite as any)
+
+      expect(result.success).toBe(true)
+      expect(result.restoredFromBackupId).toBe(latest.backupId)
+    })
+
+    it('should restore incrementals on top of full backup', async () => {
+      const full = await manager.createFullBackup(mockPGLite as any)
+      await manager.createIncrementalBackup(mockPGLite as any)
+      const inc2 = await manager.createIncrementalBackup(mockPGLite as any)
+
+      mockBucket.get.mockResolvedValue({
+        bytes: () => Promise.resolve(new Uint8Array([1, 2, 3])),
+        text: () => Promise.resolve(''),
+      })
+
+      const result = await manager.restoreFromBackup(
+        inc2.backupId,
+        mockPGLite as any
+      )
+
+      expect(result.success).toBe(true)
+      expect(result.backupsApplied).toBeGreaterThan(1) // Full + incrementals
+      expect(result.restoredFromBackupId).toBe(inc2.backupId)
+    })
+
+    it('should validate checksum during restore', async () => {
+      const backup = await manager.createFullBackup(mockPGLite as any)
+
+      // Return data with wrong checksum
+      mockBucket.get.mockResolvedValueOnce({
+        bytes: () => Promise.resolve(new Uint8Array([99, 99, 99])), // Corrupted
+        text: () => Promise.resolve(''),
+        customMetadata: { checksum: 'wrong-checksum' },
+      })
+
+      const result = await manager.restoreFromBackup(
+        backup.backupId,
+        mockPGLite as any,
+        { validateChecksum: true }
+      )
+
+      expect(result.success).toBe(false)
+      expect(result.error).toContain('checksum')
+    })
+
+    it('should fail if backup not found in R2', async () => {
+      mockBucket.get.mockResolvedValueOnce(null)
+
+      const result = await manager.restoreFromBackup(
+        'non-existent-backup-id',
+        mockPGLite as any
+      )
+
+      expect(result.success).toBe(false)
+      expect(result.error).toContain('not found')
+    })
+
+    it('should decompress backup data during restore', async () => {
+      const compressedManager = createBackupManager({
+        bucket: mockBucket as unknown as R2Bucket,
+        doId: 'test-do-123',
+        prefix: 'backups/',
+        compression: true,
+      })
+
+      const backup = await compressedManager.createFullBackup(mockPGLite as any)
+
+      mockBucket.get.mockResolvedValueOnce({
+        bytes: () => Promise.resolve(new Uint8Array([1, 2, 3])),
+        text: () => Promise.resolve(''),
+      })
+
+      const result = await compressedManager.restoreFromBackup(
+        backup.backupId,
+        mockPGLite as any
+      )
+
+      expect(result.success).toBe(true)
+    })
+
+    it('should track restore progress', async () => {
+      const backup = await manager.createFullBackup(mockPGLite as any)
+
+      const progressEvents: any[] = []
+      mockBucket.get.mockResolvedValueOnce({
+        bytes: () => Promise.resolve(new Uint8Array([1, 2, 3])),
+        text: () => Promise.resolve(''),
+      })
+
+      const result = await manager.restoreFromBackup(
+        backup.backupId,
+        mockPGLite as any,
+        { onProgress: (event: any) => progressEvents.push(event) }
+      )
+
+      expect(result.success).toBe(true)
+      expect(progressEvents.length).toBeGreaterThan(0)
+      expect(progressEvents[progressEvents.length - 1].progress).toBe(100)
+    })
+
+    it('should record restore duration', async () => {
+      const backup = await manager.createFullBackup(mockPGLite as any)
+
+      mockBucket.get.mockResolvedValueOnce({
+        bytes: () => Promise.resolve(new Uint8Array([1, 2, 3])),
+        text: () => Promise.resolve(''),
+      })
+
+      const result = await manager.restoreFromBackup(
+        backup.backupId,
+        mockPGLite as any
+      )
+
+      expect(result.durationMs).toBeDefined()
+      expect(result.durationMs).toBeGreaterThanOrEqual(0)
+    })
+  })
+
+  // ===========================================================================
+  // Tests: Backup Schedule
+  // ===========================================================================
+
+  describe('Backup Schedule', () => {
+    let manager: InstanceType<typeof BackupManager>
+
+    beforeEach(() => {
+      manager = createBackupManager({
+        bucket: mockBucket as unknown as R2Bucket,
+        doId: 'test-do-123',
+        prefix: 'backups/',
+        schedule: {
+          intervalMs: 3600000, // 1 hour
+          type: 'incremental',
+          fullBackupIntervalMs: 86400000, // 24 hours
+        },
+      })
+    })
+
+    it('should determine next backup time based on schedule', () => {
+      const nextBackup = manager.getNextBackupTime()
+
+      expect(nextBackup).toBeDefined()
+      expect(nextBackup).toBeGreaterThan(Date.now())
+    })
+
+    it('should determine if full backup is needed based on interval', () => {
+      // No backups yet - should need a full backup
+      const needsFull = manager.needsFullBackup()
+
+      expect(needsFull).toBe(true)
+    })
+
+    it('should not need full backup if recent full backup exists', async () => {
+      await manager.createFullBackup(mockPGLite as any)
+
+      const needsFull = manager.needsFullBackup()
+
+      expect(needsFull).toBe(false)
+    })
+
+    it('should request full backup after fullBackupInterval expires', async () => {
+      await manager.createFullBackup(mockPGLite as any)
+
+      // Advance time past the full backup interval
+      vi.advanceTimersByTime(86400001)
+
+      const needsFull = manager.needsFullBackup()
+
+      expect(needsFull).toBe(true)
+    })
+
+    it('should return scheduled backup type (full or incremental)', () => {
+      const backupType = manager.getScheduledBackupType()
+
+      // First backup should be full
+      expect(backupType).toBe('full')
+    })
+
+    it('should execute scheduled backup via handleAlarm', async () => {
+      const result = await manager.handleAlarm(mockPGLite as any)
+
+      expect(result.backupCreated).toBe(true)
+      expect(result.type).toBeDefined()
+      expect(result.nextAlarmMs).toBeDefined()
+    })
+
+    it('should return the configured schedule', () => {
+      const schedule = manager.getSchedule()
+
+      expect(schedule.intervalMs).toBe(3600000)
+      expect(schedule.type).toBe('incremental')
+      expect(schedule.fullBackupIntervalMs).toBe(86400000)
+    })
+  })
+
+  // ===========================================================================
+  // Tests: Backup Retention
+  // ===========================================================================
+
+  describe('Backup Retention', () => {
+    let manager: InstanceType<typeof BackupManager>
+
+    beforeEach(() => {
+      manager = createBackupManager({
+        bucket: mockBucket as unknown as R2Bucket,
+        doId: 'test-do-123',
+        prefix: 'backups/',
+        retention: {
+          maxBackups: 5,
+          maxAgeDays: 7,
+          keepMinFullBackups: 2,
+        },
+      })
+    })
+
+    it('should prune backups exceeding maxBackups', async () => {
+      // Create more backups than allowed
+      for (let i = 0; i < 7; i++) {
+        await manager.createFullBackup(mockPGLite as any)
+        vi.advanceTimersByTime(1000)
+      }
+
+      const pruneResult = await manager.pruneBackups()
+
+      expect(pruneResult.pruned).toBeGreaterThan(0)
+      expect(pruneResult.remaining).toBeLessThanOrEqual(5)
+    })
+
+    it('should prune backups older than maxAgeDays', async () => {
+      await manager.createFullBackup(mockPGLite as any)
+
+      // Advance past retention period
+      vi.advanceTimersByTime(8 * 24 * 60 * 60 * 1000) // 8 days
+
+      await manager.createFullBackup(mockPGLite as any)
+
+      const pruneResult = await manager.pruneBackups()
+
+      expect(pruneResult.pruned).toBeGreaterThan(0)
+    })
+
+    it('should always keep minimum number of full backups', async () => {
+      // Create 3 full backups with time between them
+      for (let i = 0; i < 3; i++) {
+        await manager.createFullBackup(mockPGLite as any)
+        vi.advanceTimersByTime(8 * 24 * 60 * 60 * 1000) // 8 days each
+      }
+
+      const pruneResult = await manager.pruneBackups()
+
+      // Should keep at least 2 full backups regardless of age
+      expect(pruneResult.remaining).toBeGreaterThanOrEqual(2)
+    })
+
+    it('should delete pruned backups from R2', async () => {
+      for (let i = 0; i < 7; i++) {
+        await manager.createFullBackup(mockPGLite as any)
+        vi.advanceTimersByTime(1000)
+      }
+
+      await manager.pruneBackups()
+
+      expect(mockBucket.delete).toHaveBeenCalled()
+    })
+
+    it('should update manifest after pruning', async () => {
+      for (let i = 0; i < 7; i++) {
+        await manager.createFullBackup(mockPGLite as any)
+        vi.advanceTimersByTime(1000)
+      }
+
+      await manager.pruneBackups()
+
+      const manifest = await manager.getManifest()
+      expect(manifest.entries.length).toBeLessThanOrEqual(5)
+    })
+
+    it('should not prune if no backups exceed retention limits', async () => {
+      await manager.createFullBackup(mockPGLite as any)
+
+      const pruneResult = await manager.pruneBackups()
+
+      expect(pruneResult.pruned).toBe(0)
+    })
+
+    it('should report deleted backup IDs in prune result', async () => {
+      for (let i = 0; i < 7; i++) {
+        await manager.createFullBackup(mockPGLite as any)
+        vi.advanceTimersByTime(1000)
+      }
+
+      const pruneResult = await manager.pruneBackups()
+
+      expect(pruneResult.deletedBackupIds).toBeDefined()
+      expect(pruneResult.deletedBackupIds.length).toBe(pruneResult.pruned)
+    })
+  })
+
+  // ===========================================================================
+  // Tests: Backup Statistics
+  // ===========================================================================
+
+  describe('Backup Statistics', () => {
+    let manager: InstanceType<typeof BackupManager>
+
+    beforeEach(() => {
+      manager = createBackupManager({
+        bucket: mockBucket as unknown as R2Bucket,
+        doId: 'test-do-123',
+        prefix: 'backups/',
+      })
+    })
+
+    it('should track total number of backups created', async () => {
+      await manager.createFullBackup(mockPGLite as any)
+      await manager.createFullBackup(mockPGLite as any)
+
+      const stats = manager.getStats()
+
+      expect(stats.totalBackups).toBe(2)
+    })
+
+    it('should track total backup size', async () => {
+      await manager.createFullBackup(mockPGLite as any)
+
+      const stats = manager.getStats()
+
+      expect(stats.totalSizeBytes).toBeGreaterThan(0)
+    })
+
+    it('should track last backup timestamp', async () => {
+      const beforeBackup = Date.now()
+      await manager.createFullBackup(mockPGLite as any)
+
+      const stats = manager.getStats()
+
+      expect(stats.lastBackupTimestamp).toBeGreaterThanOrEqual(beforeBackup)
+    })
+
+    it('should track backup success and failure counts', async () => {
+      await manager.createFullBackup(mockPGLite as any) // success
+
+      mockBucket.put.mockRejectedValueOnce(new Error('failed'))
+      await manager.createFullBackup(mockPGLite as any) // failure
+
+      const stats = manager.getStats()
+
+      expect(stats.successCount).toBe(1)
+      expect(stats.failureCount).toBe(1)
+    })
+
+    it('should track average backup duration', async () => {
+      await manager.createFullBackup(mockPGLite as any)
+      await manager.createFullBackup(mockPGLite as any)
+
+      const stats = manager.getStats()
+
+      expect(stats.avgDurationMs).toBeGreaterThanOrEqual(0)
+    })
+
+    it('should reset stats', () => {
+      manager.resetStats()
+
+      const stats = manager.getStats()
+
+      expect(stats.totalBackups).toBe(0)
+      expect(stats.totalSizeBytes).toBe(0)
+    })
+
+    it('should track full vs incremental backup counts separately', async () => {
+      await manager.createFullBackup(mockPGLite as any)
+      await manager.createIncrementalBackup(mockPGLite as any)
+      await manager.createIncrementalBackup(mockPGLite as any)
+
+      const stats = manager.getStats()
+
+      expect(stats.fullBackupCount).toBe(1)
+      expect(stats.incrementalBackupCount).toBe(2)
+    })
+  })
+
+  // ===========================================================================
+  // Tests: Edge Cases and Error Handling
+  // ===========================================================================
+
+  describe('Edge Cases', () => {
+    let manager: InstanceType<typeof BackupManager>
+
+    beforeEach(() => {
+      manager = createBackupManager({
+        bucket: mockBucket as unknown as R2Bucket,
+        doId: 'test-do-123',
+        prefix: 'backups/',
+      })
+    })
+
+    it('should handle empty database backup', async () => {
+      mockPGLite.query.mockResolvedValueOnce({ rows: [] }) // No tables
+
+      const result = await manager.createFullBackup(mockPGLite as any)
+
+      expect(result.success).toBe(true)
+      expect(result.tables).toEqual([])
+    })
+
+    it('should handle concurrent backup requests', async () => {
+      const backup1 = manager.createFullBackup(mockPGLite as any)
+      const backup2 = manager.createFullBackup(mockPGLite as any)
+
+      const results = await Promise.all([backup1, backup2])
+
+      // One should succeed, one should be rejected or queued
+      const successes = results.filter((r) => r.success)
+      expect(successes.length).toBeGreaterThanOrEqual(1)
+    })
+
+    it('should handle R2 timeout during backup', async () => {
+      mockBucket.put.mockImplementationOnce(
+        () => new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 30000))
+      )
+
+      vi.advanceTimersByTime(30000)
+
+      const result = await manager.createFullBackup(mockPGLite as any)
+
+      expect(result.success).toBe(false)
+    })
+
+    it('should handle very large databases', async () => {
+      // Simulate a large database with many tables
+      const tables = Array.from({ length: 100 }, (_, i) => ({
+        tablename: `table_${i}`,
+        schemaname: 'public',
+      }))
+      mockPGLite.query.mockResolvedValueOnce({ rows: tables })
+
+      const result = await manager.createFullBackup(mockPGLite as any)
+
+      expect(result.tables!.length).toBe(100)
+    })
+
+    it('should handle PGLite query errors during backup', async () => {
+      mockPGLite.query.mockRejectedValueOnce(new Error('PGLite internal error'))
+
+      const result = await manager.createFullBackup(mockPGLite as any)
+
+      expect(result.success).toBe(false)
+      expect(result.error).toContain('PGLite')
+    })
+
+    it('should handle backup of database with special characters in names', async () => {
+      mockPGLite.query.mockResolvedValueOnce({
+        rows: [{ tablename: 'table with spaces', schemaname: 'my-schema' }],
+      })
+
+      const result = await manager.createFullBackup(mockPGLite as any)
+
+      expect(result.success).toBe(true)
+    })
+
+    it('should verify backup exists in R2 after creation', async () => {
+      const backup = await manager.createFullBackup(mockPGLite as any)
+
+      mockBucket.head.mockResolvedValueOnce({ size: 100, etag: 'abc' })
+
+      const exists = await manager.verifyBackup(backup.backupId)
+
+      expect(exists).toBe(true)
+    })
+
+    it('should handle manifest not found in R2 gracefully', async () => {
+      mockBucket.get.mockResolvedValueOnce(null)
+
+      const manifest = await manager.getManifest()
+
+      expect(manifest.entries).toEqual([])
+    })
+  })
+})