@dotdo/postgres 0.1.0

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

@@ -0,0 +1,758 @@
+/**
+ * WAL Retention Policy Tests
+ * Task: postgres-yzu - Configurable WAL retention policy
+ *
+ * Tests for WAL retention policies including:
+ * - Time-based retention
+ * - Size-based retention
+ * - LSN-based retention
+ * - Combined retention policies
+ * - Legal hold
+ * - Automatic cleanup
+ * - Environment variable parsing
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import {
+  WALRetentionManager,
+  createTimeRetention,
+  createSizeRetention,
+  createLsnRetention,
+  createCombinedRetention,
+  createWALRetentionManager,
+  parseDuration,
+  parseSize,
+  parseRetentionConfigFromEnv,
+  type WALRetentionConfig,
+  type RetentionEvent,
+  type CleanupResult,
+} from './wal-retention'
+import { R2WALStorage } from './wal-r2'
+import type { SerializedWALEntry } from './wal'
+
+/**
+ * Create a mock R2 bucket with tracking
+ */
+function createMockR2Bucket() {
+  const objects = new Map<string, { data: Uint8Array; metadata?: Record<string, string>; uploaded: Date }>()
+
+  return {
+    put: vi.fn(async (key: string, data: Uint8Array | ArrayBuffer | string, options?: { customMetadata?: Record<string, string> }) => {
+      const bytes = data instanceof Uint8Array ? data : new TextEncoder().encode(String(data))
+      objects.set(key, { data: bytes, metadata: options?.customMetadata, uploaded: new Date() })
+      return { key, etag: 'test-etag', uploaded: new Date() }
+    }),
+    get: vi.fn(async (key: string) => {
+      const obj = objects.get(key)
+      if (!obj) return null
+      return {
+        key,
+        size: obj.data.length,
+        etag: 'test-etag',
+        uploaded: obj.uploaded,
+        customMetadata: obj.metadata,
+        bytes: vi.fn(async () => obj.data),
+        text: vi.fn(async () => new TextDecoder().decode(obj.data)),
+      }
+    }),
+    head: vi.fn(async (key: string) => {
+      const obj = objects.get(key)
+      if (!obj) return null
+      return {
+        key,
+        size: obj.data.length,
+        etag: 'test-etag',
+        uploaded: obj.uploaded,
+        customMetadata: obj.metadata,
+      }
+    }),
+    delete: vi.fn(async (keys: string | string[]) => {
+      const keyArray = Array.isArray(keys) ? keys : [keys]
+      for (const key of keyArray) {
+        objects.delete(key)
+      }
+    }),
+    list: vi.fn(async (options?: { prefix?: string; cursor?: string; limit?: number }) => {
+      const prefix = options?.prefix || ''
+      const limit = options?.limit || 1000
+      const matchingKeys = Array.from(objects.keys())
+        .filter(k => k.startsWith(prefix))
+        .sort()
+        .slice(0, limit)
+
+      return {
+        objects: matchingKeys.map(key => {
+          const obj = objects.get(key)!
+          return {
+            key,
+            size: obj.data.length,
+            etag: 'test-etag',
+            uploaded: obj.uploaded,
+            customMetadata: obj.metadata,
+          }
+        }),
+        truncated: matchingKeys.length === limit,
+        cursor: matchingKeys.length === limit ? 'next-cursor' : undefined,
+      }
+    }),
+    _objects: objects,
+  } as unknown as R2Bucket
+}
+
+/**
+ * Create a mock DO state
+ */
+function createMockState() {
+  const store = new Map<string, unknown>()
+  return {
+    storage: {
+      get: vi.fn(async <T>(key: string): Promise<T | undefined> => store.get(key) as T | undefined),
+      put: vi.fn(async (key: string, value: unknown): Promise<void> => { store.set(key, value) }),
+      delete: vi.fn(async (key: string): Promise<boolean> => store.delete(key)),
+      list: vi.fn(),
+      _store: store,
+    },
+    id: { toString: () => 'test-do-id' },
+    blockConcurrencyWhile: vi.fn((fn: () => Promise<void>) => fn()),
+    waitUntil: vi.fn(),
+  } as unknown as DurableObjectState
+}
+
+/**
+ * Create sample WAL entries
+ */
+function createSampleEntries(count: number, startLsn = 1): SerializedWALEntry[] {
+  return Array.from({ length: count }, (_, i) => ({
+    lsn: String(startLsn + i),
+    operation: 'INSERT' as const,
+    schema: 'public',
+    table: 'users',
+    timestamp: Date.now(),
+    newRow: { id: startLsn + i, name: `User ${startLsn + i}` },
+  }))
+}
+
+/**
+ * Create storage with pre-populated segments at specific times
+ */
+async function createStorageWithSegments(
+  bucket: R2Bucket,
+  segments: Array<{
+    ageHours: number
+    entryCount: number
+    startLsn: number
+  }>
+) {
+  const storage = new R2WALStorage({
+    bucket,
+    doId: 'test-do',
+  })
+
+  const now = Date.now()
+
+  for (const seg of segments) {
+    const entries = createSampleEntries(seg.entryCount, seg.startLsn)
+
+    // Manually create segment with custom timestamp
+    const segmentTime = now - seg.ageHours * 60 * 60 * 1000
+    const date = new Date(segmentTime)
+    const year = date.getUTCFullYear()
+    const month = String(date.getUTCMonth() + 1).padStart(2, '0')
+    const day = String(date.getUTCDate()).padStart(2, '0')
+    const hour = String(date.getUTCHours()).padStart(2, '0')
+    const startLsn = String(seg.startLsn).padStart(20, '0')
+    const endLsn = String(seg.startLsn + seg.entryCount - 1).padStart(20, '0')
+
+    const key = `wal/test-do/${year}/${month}/${day}/${hour}/${startLsn}-${endLsn}.wal`
+    const data = new TextEncoder().encode(entries.map(e => JSON.stringify(e)).join('\n'))
+
+    await bucket.put(key, data, {
+      customMetadata: {
+        doId: 'test-do',
+        startLsn: String(seg.startLsn),
+        endLsn: String(seg.startLsn + seg.entryCount - 1),
+        entryCount: String(seg.entryCount),
+        createdAt: String(segmentTime),
+        compressedSize: String(data.length),
+        uncompressedSize: String(data.length),
+        compression: 'none',
+      },
+    })
+  }
+
+  return storage
+}
+
+describe('Duration and Size Parsing', () => {
+  describe('parseDuration', () => {
+    it('should parse days', () => {
+      expect(parseDuration('30d')).toBe(30 * 24 * 60 * 60 * 1000)
+      expect(parseDuration('1d')).toBe(24 * 60 * 60 * 1000)
+    })
+
+    it('should parse hours', () => {
+      expect(parseDuration('12h')).toBe(12 * 60 * 60 * 1000)
+      expect(parseDuration('1h')).toBe(60 * 60 * 1000)
+    })
+
+    it('should parse minutes', () => {
+      expect(parseDuration('30m')).toBe(30 * 60 * 1000)
+      expect(parseDuration('1m')).toBe(60 * 1000)
+    })
+
+    it('should parse seconds', () => {
+      expect(parseDuration('60s')).toBe(60 * 1000)
+      expect(parseDuration('1s')).toBe(1000)
+    })
+
+    it('should parse milliseconds', () => {
+      expect(parseDuration('1000ms')).toBe(1000)
+      expect(parseDuration('500ms')).toBe(500)
+    })
+
+    it('should handle decimal values', () => {
+      expect(parseDuration('1.5d')).toBe(1.5 * 24 * 60 * 60 * 1000)
+      expect(parseDuration('2.5h')).toBe(2.5 * 60 * 60 * 1000)
+    })
+
+    it('should throw on invalid format', () => {
+      expect(() => parseDuration('invalid')).toThrow()
+      expect(() => parseDuration('30')).toThrow()
+      expect(() => parseDuration('30x')).toThrow()
+    })
+  })
+
+  describe('parseSize', () => {
+    it('should parse bytes', () => {
+      expect(parseSize('100B')).toBe(100)
+      expect(parseSize('1B')).toBe(1)
+    })
+
+    it('should parse kilobytes', () => {
+      expect(parseSize('10KB')).toBe(10 * 1024)
+      expect(parseSize('1KB')).toBe(1024)
+    })
+
+    it('should parse megabytes', () => {
+      expect(parseSize('10MB')).toBe(10 * 1024 * 1024)
+      expect(parseSize('500MB')).toBe(500 * 1024 * 1024)
+    })
+
+    it('should parse gigabytes', () => {
+      expect(parseSize('1GB')).toBe(1024 * 1024 * 1024)
+      expect(parseSize('10GB')).toBe(10 * 1024 * 1024 * 1024)
+    })
+
+    it('should parse terabytes', () => {
+      expect(parseSize('1TB')).toBe(1024 * 1024 * 1024 * 1024)
+    })
+
+    it('should handle decimal values', () => {
+      expect(parseSize('1.5GB')).toBe(1.5 * 1024 * 1024 * 1024)
+    })
+
+    it('should throw on invalid format', () => {
+      expect(() => parseSize('invalid')).toThrow()
+      expect(() => parseSize('100')).toThrow()
+      expect(() => parseSize('100PB')).toThrow()
+    })
+  })
+})
+
+describe('Retention Policy Factory Functions', () => {
+  describe('createTimeRetention', () => {
+    it('should create time-based retention policy', () => {
+      const policy = createTimeRetention('30d')
+      expect(policy.type).toBe('time')
+      expect(policy.maxRetentionMs).toBe(30 * 24 * 60 * 60 * 1000)
+      expect(policy.minRetentionMs).toBeUndefined()
+    })
+
+    it('should create time-based retention with min retention', () => {
+      const policy = createTimeRetention('90d', '7d')
+      expect(policy.type).toBe('time')
+      expect(policy.maxRetentionMs).toBe(90 * 24 * 60 * 60 * 1000)
+      expect(policy.minRetentionMs).toBe(7 * 24 * 60 * 60 * 1000)
+    })
+  })
+
+  describe('createSizeRetention', () => {
+    it('should create size-based retention policy', () => {
+      const policy = createSizeRetention('1GB')
+      expect(policy.type).toBe('size')
+      expect(policy.maxSizeBytes).toBe(1024 * 1024 * 1024)
+      expect(policy.evictOldestFirst).toBe(true)
+    })
+
+    it('should allow evicting newest first', () => {
+      const policy = createSizeRetention('500MB', false)
+      expect(policy.evictOldestFirst).toBe(false)
+    })
+  })
+
+  describe('createLsnRetention', () => {
+    it('should create LSN-based retention policy with bigint', () => {
+      const policy = createLsnRetention(1000n)
+      expect(policy.type).toBe('lsn')
+      expect(policy.minLsn).toBe(1000n)
+    })
+
+    it('should create LSN-based retention policy with string', () => {
+      const policy = createLsnRetention('1000')
+      expect(policy.type).toBe('lsn')
+      expect(policy.minLsn).toBe('1000')
+    })
+  })
+
+  describe('createCombinedRetention', () => {
+    it('should create combined retention policy', () => {
+      const policy = createCombinedRetention({
+        time: { maxRetentionMs: 30 * 24 * 60 * 60 * 1000 },
+        size: { maxSizeBytes: 1024 * 1024 * 1024 },
+      })
+      expect(policy.type).toBe('combined')
+      expect(policy.time?.maxRetentionMs).toBe(30 * 24 * 60 * 60 * 1000)
+      expect(policy.size?.maxSizeBytes).toBe(1024 * 1024 * 1024)
+    })
+  })
+})
+
+describe('WALRetentionManager', () => {
+  let mockBucket: R2Bucket
+  let mockState: DurableObjectState
+  let storage: R2WALStorage
+
+  beforeEach(() => {
+    vi.useFakeTimers()
+    mockBucket = createMockR2Bucket()
+    mockState = createMockState()
+    storage = new R2WALStorage({
+      bucket: mockBucket,
+      doId: 'test-do',
+      state: mockState,
+    })
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  describe('constructor and configuration', () => {
+    it('should create retention manager with time policy', () => {
+      const manager = new WALRetentionManager(storage, {
+        policy: createTimeRetention('30d'),
+      })
+      expect(manager.getConfig().policy.type).toBe('time')
+    })
+
+    it('should use default values', () => {
+      const manager = new WALRetentionManager(storage, {
+        policy: createTimeRetention('30d'),
+      })
+      const config = manager.getConfig()
+      expect(config.autoCleanup).toBe(true)
+      expect(config.cleanupIntervalMs).toBe(60 * 60 * 1000)
+      expect(config.dryRun).toBe(false)
+    })
+
+    it('should accept custom configuration', () => {
+      const manager = new WALRetentionManager(storage, {
+        policy: createTimeRetention('7d'),
+        autoCleanup: false,
+        cleanupIntervalMs: 30 * 60 * 1000,
+        dryRun: true,
+      })
+      const config = manager.getConfig()
+      expect(config.autoCleanup).toBe(false)
+      expect(config.cleanupIntervalMs).toBe(30 * 60 * 1000)
+      expect(config.dryRun).toBe(true)
+    })
+  })
+
+  describe('setConfig', () => {
+    it('should update configuration', () => {
+      const manager = new WALRetentionManager(storage, {
+        policy: createTimeRetention('30d'),
+      })
+
+      manager.setConfig({
+        autoCleanup: false,
+        cleanupIntervalMs: 15 * 60 * 1000,
+      })
+
+      const config = manager.getConfig()
+      expect(config.autoCleanup).toBe(false)
+      expect(config.cleanupIntervalMs).toBe(15 * 60 * 1000)
+    })
+
+    it('should emit policy_changed event', () => {
+      const events: RetentionEvent[] = []
+      const manager = new WALRetentionManager(storage, {
+        policy: createTimeRetention('30d'),
+        onRetentionEvent: (event) => events.push(event),
+      })
+
+      manager.setConfig({
+        policy: createSizeRetention('1GB'),
+      })
+
+      expect(events.some(e => e.type === 'policy_changed')).toBe(true)
+    })
+  })
+
+  describe('legal hold', () => {
+    it('should set legal hold', () => {
+      const manager = new WALRetentionManager(storage, {
+        policy: createTimeRetention('30d'),
+      })
+
+      manager.setLegalHold({
+        enabled: true,
+        reason: 'Investigation',
+      })
+
+      const hold = manager.getLegalHold()
+      expect(hold?.enabled).toBe(true)
+      expect(hold?.reason).toBe('Investigation')
+      expect(hold?.appliedAt).toBeDefined()
+    })
+
+    it('should check if legal hold is active', () => {
+      const manager = new WALRetentionManager(storage, {
+        policy: createTimeRetention('30d'),
+      })
+
+      expect(manager.isLegalHoldActive()).toBe(false)
+
+      manager.setLegalHold({ enabled: true })
+      expect(manager.isLegalHoldActive()).toBe(true)
+
+      manager.setLegalHold({ enabled: false })
+      expect(manager.isLegalHoldActive()).toBe(false)
+    })
+
+    it('should respect legal hold expiry', () => {
+      const manager = new WALRetentionManager(storage, {
+        policy: createTimeRetention('30d'),
+      })
+
+      const now = Date.now()
+      manager.setLegalHold({
+        enabled: true,
+        expiresAt: now + 1000, // Expires in 1 second
+      })
+
+      expect(manager.isLegalHoldActive()).toBe(true)
+
+      // Advance time past expiry
+      vi.advanceTimersByTime(2000)
+      expect(manager.isLegalHoldActive()).toBe(false)
+    })
+
+    it('should prevent deletion when legal hold is active', async () => {
+      vi.useRealTimers()
+
+      const bucket = createMockR2Bucket()
+      const testStorage = await createStorageWithSegments(bucket, [
+        { ageHours: 48 * 24, entryCount: 5, startLsn: 1 }, // 48 days old (should be deleted)
+      ])
+
+      const manager = new WALRetentionManager(testStorage, {
+        policy: createTimeRetention('30d'),
+        legalHold: { enabled: true, reason: 'Test' },
+      })
+
+      const result = await manager.cleanup()
+
+      expect(result.success).toBe(true)
+      expect(result.segmentsDeleted).toBe(0)
+      expect(result.reason).toBe('Legal hold active')
+    })
+  })
+
+  describe('cleanup with time-based retention', () => {
+    it('should delete segments older than retention period', async () => {
+      vi.useRealTimers()
+
+      const bucket = createMockR2Bucket()
+      const testStorage = await createStorageWithSegments(bucket, [
+        { ageHours: 35 * 24, entryCount: 5, startLsn: 1 },   // 35 days old
+        { ageHours: 25 * 24, entryCount: 5, startLsn: 6 },   // 25 days old
+        { ageHours: 10 * 24, entryCount: 5, startLsn: 11 },  // 10 days old
+      ])
+
+      const manager = new WALRetentionManager(testStorage, {
+        policy: createTimeRetention('30d'),
+        minAgeBeforeDeleteMs: 0, // Disable safety buffer for testing
+      })
+
+      const result = await manager.cleanup()
+
+      expect(result.success).toBe(true)
+      expect(result.segmentsDeleted).toBe(1) // Only 35-day-old segment
+      expect(result.segmentsRetained).toBe(2)
+    })
+
+    it('should respect minRetention', async () => {
+      vi.useRealTimers()
+
+      const bucket = createMockR2Bucket()
+      const testStorage = await createStorageWithSegments(bucket, [
+        { ageHours: 5 * 24, entryCount: 5, startLsn: 1 }, // 5 days old
+      ])
+
+      const manager = new WALRetentionManager(testStorage, {
+        policy: createTimeRetention('30d', '7d'), // min 7 days, max 30 days
+        minAgeBeforeDeleteMs: 0,
+      })
+
+      const result = await manager.cleanup()
+
+      expect(result.success).toBe(true)
+      expect(result.segmentsDeleted).toBe(0) // Within min retention
+    })
+  })
+
+  describe('cleanup with LSN-based retention', () => {
+    it('should retain segments from minLsn onward', async () => {
+      vi.useRealTimers()
+
+      const bucket = createMockR2Bucket()
+      const testStorage = await createStorageWithSegments(bucket, [
+        { ageHours: 1, entryCount: 5, startLsn: 1 },   // LSN 1-5
+        { ageHours: 1, entryCount: 5, startLsn: 6 },   // LSN 6-10
+        { ageHours: 1, entryCount: 5, startLsn: 11 },  // LSN 11-15
+      ])
+
+      const manager = new WALRetentionManager(testStorage, {
+        policy: createLsnRetention(10n),
+        minAgeBeforeDeleteMs: 0,
+      })
+
+      const result = await manager.cleanup()
+
+      expect(result.success).toBe(true)
+      expect(result.segmentsDeleted).toBe(1) // Segment 1-5 deleted
+      expect(result.segmentsRetained).toBe(2) // Segments 6-10 and 11-15 retained
+    })
+  })
+
+  describe('dry run mode', () => {
+    it('should not delete in dry run mode', async () => {
+      vi.useRealTimers()
+
+      const bucket = createMockR2Bucket()
+      const testStorage = await createStorageWithSegments(bucket, [
+        { ageHours: 35 * 24, entryCount: 5, startLsn: 1 },
+      ])
+
+      const deleteCount = (bucket as any)._objects.size
+
+      const manager = new WALRetentionManager(testStorage, {
+        policy: createTimeRetention('30d'),
+        dryRun: true,
+        minAgeBeforeDeleteMs: 0,
+      })
+
+      const result = await manager.cleanup()
+
+      expect(result.success).toBe(true)
+      expect(result.segmentsDeleted).toBe(1) // Reports deletion
+      // But bucket still has the same number of objects
+      expect((bucket as any)._objects.size).toBe(deleteCount)
+    })
+  })
+
+  describe('preview cleanup', () => {
+    it('should preview what would be cleaned up', async () => {
+      vi.useRealTimers()
+
+      const bucket = createMockR2Bucket()
+      const testStorage = await createStorageWithSegments(bucket, [
+        { ageHours: 35 * 24, entryCount: 5, startLsn: 1 },   // Old
+        { ageHours: 10 * 24, entryCount: 5, startLsn: 6 },   // Recent
+      ])
+
+      const manager = new WALRetentionManager(testStorage, {
+        policy: createTimeRetention('30d'),
+        minAgeBeforeDeleteMs: 0,
+      })
+
+      const preview = await manager.previewCleanup()
+
+      expect(preview.segmentsToDelete.length).toBe(1)
+      expect(preview.segmentsToRetain.length).toBe(1)
+    })
+  })
+
+  describe('statistics', () => {
+    it('should track cleanup statistics', async () => {
+      vi.useRealTimers()
+
+      const bucket = createMockR2Bucket()
+      const testStorage = await createStorageWithSegments(bucket, [
+        { ageHours: 35 * 24, entryCount: 5, startLsn: 1 },
+      ])
+
+      const manager = new WALRetentionManager(testStorage, {
+        policy: createTimeRetention('30d'),
+        minAgeBeforeDeleteMs: 0,
+      })
+
+      await manager.cleanup()
+
+      const stats = manager.getStats()
+      expect(stats.totalCleanups).toBe(1)
+      expect(stats.successfulCleanups).toBe(1)
+      expect(stats.failedCleanups).toBe(0)
+      expect(stats.lastCleanupAt).not.toBeNull()
+    })
+  })
+
+  describe('events', () => {
+    it('should emit cleanup events', async () => {
+      vi.useRealTimers()
+
+      const events: RetentionEvent[] = []
+      const bucket = createMockR2Bucket()
+      const testStorage = await createStorageWithSegments(bucket, [
+        { ageHours: 35 * 24, entryCount: 5, startLsn: 1 },
+      ])
+
+      const manager = new WALRetentionManager(testStorage, {
+        policy: createTimeRetention('30d'),
+        minAgeBeforeDeleteMs: 0,
+        onRetentionEvent: (event) => events.push(event),
+      })
+
+      await manager.cleanup()
+
+      expect(events.some(e => e.type === 'cleanup_started')).toBe(true)
+      expect(events.some(e => e.type === 'cleanup_completed')).toBe(true)
+      expect(events.some(e => e.type === 'segment_deleted')).toBe(true)
+    })
+  })
+
+  describe('auto cleanup', () => {
+    it('should start and stop auto cleanup', () => {
+      const manager = new WALRetentionManager(storage, {
+        policy: createTimeRetention('30d'),
+      })
+
+      expect(manager.isAutoCleanupRunning()).toBe(false)
+
+      manager.startAutoCleanup()
+      expect(manager.isAutoCleanupRunning()).toBe(true)
+
+      manager.stopAutoCleanup()
+      expect(manager.isAutoCleanupRunning()).toBe(false)
+    })
+  })
+})
+
+describe('createWALRetentionManager', () => {
+  let storage: R2WALStorage
+
+  beforeEach(() => {
+    const mockBucket = createMockR2Bucket()
+    const mockState = createMockState()
+    storage = new R2WALStorage({
+      bucket: mockBucket,
+      doId: 'test-do',
+      state: mockState,
+    })
+  })
+
+  it('should create manager with duration string', () => {
+    const manager = createWALRetentionManager(storage, '30d')
+    expect(manager.getConfig().policy.type).toBe('time')
+  })
+
+  it('should create manager with full config', () => {
+    const manager = createWALRetentionManager(storage, {
+      policy: createSizeRetention('1GB'),
+      autoCleanup: false,
+    })
+    expect(manager.getConfig().policy.type).toBe('size')
+    expect(manager.getConfig().autoCleanup).toBe(false)
+  })
+})
+
+describe('parseRetentionConfigFromEnv', () => {
+  it('should parse time-based retention from env', () => {
+    const config = parseRetentionConfigFromEnv({
+      WAL_RETENTION_TYPE: 'time',
+      WAL_RETENTION_MAX_TIME: '30d',
+      WAL_RETENTION_MIN_TIME: '7d',
+    })
+
+    expect(config.policy.type).toBe('time')
+    if (config.policy.type === 'time') {
+      expect(config.policy.maxRetentionMs).toBe(30 * 24 * 60 * 60 * 1000)
+      expect(config.policy.minRetentionMs).toBe(7 * 24 * 60 * 60 * 1000)
+    }
+  })
+
+  it('should parse size-based retention from env', () => {
+    const config = parseRetentionConfigFromEnv({
+      WAL_RETENTION_TYPE: 'size',
+      WAL_RETENTION_MAX_SIZE: '500MB',
+    })
+
+    expect(config.policy.type).toBe('size')
+    if (config.policy.type === 'size') {
+      expect(config.policy.maxSizeBytes).toBe(500 * 1024 * 1024)
+    }
+  })
+
+  it('should parse LSN-based retention from env', () => {
+    const config = parseRetentionConfigFromEnv({
+      WAL_RETENTION_TYPE: 'lsn',
+      WAL_RETENTION_MIN_LSN: '1000',
+    })
+
+    expect(config.policy.type).toBe('lsn')
+    if (config.policy.type === 'lsn') {
+      expect(config.policy.minLsn).toBe('1000')
+    }
+  })
+
+  it('should parse combined retention from env', () => {
+    const config = parseRetentionConfigFromEnv({
+      WAL_RETENTION_TYPE: 'combined',
+      WAL_RETENTION_MAX_TIME: '30d',
+      WAL_RETENTION_MAX_SIZE: '1GB',
+    })
+
+    expect(config.policy.type).toBe('combined')
+    if (config.policy.type === 'combined') {
+      expect(config.policy.time?.maxRetentionMs).toBe(30 * 24 * 60 * 60 * 1000)
+      expect(config.policy.size?.maxSizeBytes).toBe(1024 * 1024 * 1024)
+    }
+  })
+
+  it('should parse cleanup options from env', () => {
+    const config = parseRetentionConfigFromEnv({
+      WAL_RETENTION_TYPE: 'time',
+      WAL_RETENTION_MAX_TIME: '30d',
+      WAL_RETENTION_AUTO_CLEANUP: 'false',
+      WAL_RETENTION_CLEANUP_INTERVAL: '30m',
+      WAL_RETENTION_DRY_RUN: 'true',
+    })
+
+    expect(config.autoCleanup).toBe(false)
+    expect(config.cleanupIntervalMs).toBe(30 * 60 * 1000)
+    expect(config.dryRun).toBe(true)
+  })
+
+  it('should use defaults when env vars not set', () => {
+    const config = parseRetentionConfigFromEnv({})
+
+    expect(config.policy.type).toBe('time')
+    if (config.policy.type === 'time') {
+      expect(config.policy.maxRetentionMs).toBe(30 * 24 * 60 * 60 * 1000) // 30 days
+    }
+    expect(config.autoCleanup).toBe(true)
+    expect(config.cleanupIntervalMs).toBe(60 * 60 * 1000) // 1 hour
+    expect(config.dryRun).toBe(false)
+  })
+})