@dotdo/postgres 0.1.0

package/src/iceberg/scheduler.test.ts

@@ -0,0 +1,861 @@
+/**
+ * Iceberg Snapshot Scheduler Tests
+ * Task: postgres-uw7 - Snapshot scheduling and automation
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import {
+  SnapshotScheduler,
+  createSnapshotScheduler,
+  parseNextRun,
+  isDue,
+  type SnapshotSchedule,
+  type WriteThreshold,
+  type SizePolicy,
+  type LifecyclePolicy,
+  type SnapshotSchedulerConfig,
+} from './scheduler'
+import {
+  createMockBucket,
+  createMockState,
+  createTestMetadata,
+  type MockR2BucketWithStorage,
+} from './test-fixtures'
+
+describe('SnapshotScheduler', () => {
+  let bucket: MockR2BucketWithStorage
+  let state: DurableObjectState
+  let scheduler: SnapshotScheduler
+
+  beforeEach(async () => {
+    bucket = createMockBucket()
+    state = createMockState()
+
+    // Create test table metadata
+    const metadata = createTestMetadata()
+    bucket._storage.set('iceberg/test-table/metadata/version-hint.text', {
+      data: '1',
+      size: 1,
+      uploaded: new Date(),
+    })
+    bucket._storage.set('iceberg/test-table/metadata/v1.metadata.json', {
+      data: JSON.stringify(metadata),
+      size: JSON.stringify(metadata).length,
+      uploaded: new Date(),
+    })
+
+    scheduler = createSnapshotScheduler({
+      bucket,
+      tablePath: 'iceberg',
+      state,
+    })
+
+    await scheduler.initialize()
+  })
+
+  describe('Initialization', () => {
+    it('should initialize without error', async () => {
+      const newScheduler = createSnapshotScheduler({
+        bucket,
+        tablePath: 'iceberg',
+      })
+
+      await expect(newScheduler.initialize()).resolves.not.toThrow()
+    })
+
+    it('should load state from Durable Object storage', async () => {
+      // Setup state
+      const schedules = [
+        {
+          table: 'test-table',
+          cron: '0 * * * *',
+          nextRun: new Date(Date.now() + 3600000).toISOString(),
+          lastRun: null,
+          enabled: true,
+        },
+      ]
+
+      await state.storage.put('__iceberg_schedules__', schedules)
+
+      const newScheduler = createSnapshotScheduler({
+        bucket,
+        tablePath: 'iceberg',
+        state,
+      })
+
+      await newScheduler.initialize()
+
+      const loadedSchedules = newScheduler.listScheduled()
+      expect(loadedSchedules).toHaveLength(1)
+      expect(loadedSchedules[0]?.table).toBe('test-table')
+    })
+  })
+
+  describe('Schedule Management', () => {
+    it('should schedule hourly snapshots', async () => {
+      const schedule = await scheduler.schedule('test-table', '0 * * * *')
+
+      expect(schedule.table).toBe('test-table')
+      expect(schedule.cron).toBe('0 * * * *')
+      expect(schedule.enabled).toBe(true)
+      expect(schedule.nextRun).toBeDefined()
+    })
+
+    it('should schedule daily snapshots', async () => {
+      const schedule = await scheduler.schedule('test-table', '0 0 * * *')
+
+      expect(schedule.table).toBe('test-table')
+      expect(schedule.cron).toBe('0 0 * * *')
+    })
+
+    it('should schedule weekly snapshots', async () => {
+      const schedule = await scheduler.schedule('test-table', '0 0 * * 0')
+
+      expect(schedule.table).toBe('test-table')
+      expect(schedule.cron).toBe('0 0 * * 0')
+    })
+
+    it('should throw on invalid cron expression', async () => {
+      await expect(
+        scheduler.schedule('test-table', 'invalid')
+      ).rejects.toThrow('Invalid cron expression')
+    })
+
+    it('should unschedule snapshots', async () => {
+      await scheduler.schedule('test-table', '0 * * * *')
+
+      const deleted = await scheduler.unschedule('test-table')
+      expect(deleted).toBe(true)
+
+      const schedules = scheduler.listScheduled()
+      expect(schedules).toHaveLength(0)
+    })
+
+    it('should toggle schedule enabled state', async () => {
+      await scheduler.schedule('test-table', '0 * * * *')
+
+      const disabled = await scheduler.toggleSchedule('test-table', false)
+      expect(disabled?.enabled).toBe(false)
+
+      const enabled = await scheduler.toggleSchedule('test-table', true)
+      expect(enabled?.enabled).toBe(true)
+    })
+
+    it('should get schedule for table', async () => {
+      await scheduler.schedule('test-table', '0 * * * *')
+
+      const schedule = scheduler.getSchedule('test-table')
+      expect(schedule?.table).toBe('test-table')
+    })
+
+    it('should list all schedules', async () => {
+      await scheduler.schedule('table1', '0 * * * *')
+      await scheduler.schedule('table2', '0 0 * * *')
+
+      const schedules = scheduler.listScheduled()
+      expect(schedules).toHaveLength(2)
+    })
+
+    it('should update alarm when scheduling', async () => {
+      await scheduler.schedule('test-table', '0 * * * *')
+
+      expect(state.storage.setAlarm).toHaveBeenCalled()
+    })
+  })
+
+  describe('Write Threshold Management', () => {
+    it('should set write threshold', async () => {
+      const threshold = await scheduler.setThreshold('test-table', 10000)
+
+      expect(threshold.table).toBe('test-table')
+      expect(threshold.writeCount).toBe(10000)
+      expect(threshold.currentCount).toBe(0)
+      expect(threshold.enabled).toBe(true)
+    })
+
+    it('should throw on invalid write count', async () => {
+      await expect(
+        scheduler.setThreshold('test-table', 0)
+      ).rejects.toThrow('Write count must be positive')
+
+      await expect(
+        scheduler.setThreshold('test-table', -100)
+      ).rejects.toThrow('Write count must be positive')
+    })
+
+    it('should increment write count', async () => {
+      await scheduler.setThreshold('test-table', 100)
+
+      const shouldSnapshot1 = await scheduler.incrementWriteCount('test-table', 50)
+      expect(shouldSnapshot1).toBe(false)
+
+      const threshold1 = scheduler.getThreshold('test-table')
+      expect(threshold1?.currentCount).toBe(50)
+
+      const shouldSnapshot2 = await scheduler.incrementWriteCount('test-table', 50)
+      expect(shouldSnapshot2).toBe(true)
+
+      const threshold2 = scheduler.getThreshold('test-table')
+      expect(threshold2?.currentCount).toBe(0) // Reset after threshold
+    })
+
+    it('should reset counter after reaching threshold', async () => {
+      await scheduler.setThreshold('test-table', 10)
+
+      await scheduler.incrementWriteCount('test-table', 15)
+
+      const threshold = scheduler.getThreshold('test-table')
+      expect(threshold?.currentCount).toBe(0)
+      expect(threshold?.lastSnapshot).toBeDefined()
+    })
+
+    it('should remove write threshold', async () => {
+      await scheduler.setThreshold('test-table', 10000)
+
+      const deleted = await scheduler.removeThreshold('test-table')
+      expect(deleted).toBe(true)
+
+      const thresholds = scheduler.listThresholds()
+      expect(thresholds).toHaveLength(0)
+    })
+
+    it('should list all thresholds', async () => {
+      await scheduler.setThreshold('table1', 10000)
+      await scheduler.setThreshold('table2', 20000)
+
+      const thresholds = scheduler.listThresholds()
+      expect(thresholds).toHaveLength(2)
+    })
+
+    it('should ignore disabled thresholds', async () => {
+      await scheduler.setThreshold('test-table', 100)
+
+      const threshold = scheduler.getThreshold('test-table')
+      if (threshold) {
+        threshold.enabled = false
+      }
+
+      const shouldSnapshot = await scheduler.incrementWriteCount('test-table', 200)
+      expect(shouldSnapshot).toBe(false)
+    })
+  })
+
+  describe('Statistics', () => {
+    it('should track scheduled tables count', async () => {
+      await scheduler.schedule('table1', '0 * * * *')
+      await scheduler.schedule('table2', '0 0 * * *')
+
+      const stats = scheduler.getStats()
+      expect(stats.scheduledTablesCount).toBe(2)
+    })
+
+    it('should track threshold tables count', async () => {
+      await scheduler.setThreshold('table1', 10000)
+      await scheduler.setThreshold('table2', 20000)
+
+      const stats = scheduler.getStats()
+      expect(stats.thresholdTablesCount).toBe(2)
+    })
+
+    it('should reset statistics', async () => {
+      await scheduler.schedule('table1', '0 * * * *')
+      await scheduler.setThreshold('table2', 10000)
+
+      await scheduler.resetStats()
+
+      const stats = scheduler.getStats()
+      expect(stats.scheduledSnapshotsCreated).toBe(0)
+      expect(stats.thresholdSnapshotsCreated).toBe(0)
+      expect(stats.retentionEnforcements).toBe(0)
+    })
+  })
+})
+
+describe('Cron Parsing', () => {
+  describe('parseNextRun', () => {
+    it('should parse hourly cron (0 * * * *)', () => {
+      const now = new Date('2024-01-15T10:30:00Z')
+      const next = parseNextRun('0 * * * *', now)
+
+      expect(next.getMinutes()).toBe(0)
+      // Next hour should be after current hour
+      expect(next.getTime()).toBeGreaterThan(now.getTime())
+      // Should be within the next 2 hours
+      expect(next.getTime() - now.getTime()).toBeLessThan(2 * 60 * 60 * 1000)
+    })
+
+    it('should parse daily cron (0 0 * * *)', () => {
+      const now = new Date('2024-01-15T10:30:00Z')
+      const next = parseNextRun('0 0 * * *', now)
+
+      expect(next.getMinutes()).toBe(0)
+      expect(next.getHours()).toBe(0)
+      expect(next.getDate()).toBe(16)
+    })
+
+    it('should parse weekly cron (0 0 * * 0)', () => {
+      const now = new Date('2024-01-15T10:30:00Z') // Monday
+      const next = parseNextRun('0 0 * * 0', now)
+
+      expect(next.getMinutes()).toBe(0)
+      expect(next.getHours()).toBe(0)
+      expect(next.getDay()).toBe(0) // Sunday
+    })
+
+    it('should parse every 5 minutes (*/5 * * * *)', () => {
+      const now = new Date('2024-01-15T10:32:00Z')
+      const next = parseNextRun('*/5 * * * *', now)
+
+      expect(next.getMinutes()).toBe(35)
+    })
+
+    it('should parse specific time (30 14 * * *)', () => {
+      const now = new Date('2024-01-15T10:30:00Z')
+      const next = parseNextRun('30 14 * * *', now)
+
+      expect(next.getMinutes()).toBe(30)
+      expect(next.getHours()).toBe(14)
+    })
+
+    it('should throw on invalid cron expression', () => {
+      expect(() => parseNextRun('invalid')).toThrow('Invalid cron expression')
+      expect(() => parseNextRun('0 * * *')).toThrow('Invalid cron expression')
+      expect(() => parseNextRun('0 * * * * *')).toThrow('Invalid cron expression')
+    })
+
+    it('should handle month boundaries', () => {
+      const now = new Date('2024-01-31T23:30:00Z')
+      const next = parseNextRun('0 0 * * *', now)
+
+      expect(next.getDate()).toBe(1)
+      expect(next.getMonth()).toBe(1) // February
+    })
+
+    it('should handle year boundaries', () => {
+      const now = new Date('2024-12-31T23:30:00Z')
+      const next = parseNextRun('0 0 * * *', now)
+
+      expect(next.getDate()).toBe(1)
+      expect(next.getMonth()).toBe(0) // January
+      expect(next.getFullYear()).toBe(2025)
+    })
+  })
+
+  describe('isDue', () => {
+    it('should return true when schedule is due', () => {
+      const schedule: SnapshotSchedule = {
+        table: 'test',
+        cron: '0 * * * *',
+        nextRun: new Date(Date.now() - 1000).toISOString(), // 1 second ago
+        lastRun: null,
+        enabled: true,
+      }
+
+      expect(isDue(schedule)).toBe(true)
+    })
+
+    it('should return false when schedule is not due', () => {
+      const schedule: SnapshotSchedule = {
+        table: 'test',
+        cron: '0 * * * *',
+        nextRun: new Date(Date.now() + 3600000).toISOString(), // 1 hour from now
+        lastRun: null,
+        enabled: true,
+      }
+
+      expect(isDue(schedule)).toBe(false)
+    })
+
+    it('should return false when schedule is disabled', () => {
+      const schedule: SnapshotSchedule = {
+        table: 'test',
+        cron: '0 * * * *',
+        nextRun: new Date(Date.now() - 1000).toISOString(),
+        lastRun: null,
+        enabled: false,
+      }
+
+      expect(isDue(schedule)).toBe(false)
+    })
+  })
+})
+
+describe('Edge Cases', () => {
+  it('should handle multiple schedules for different tables', async () => {
+    const bucket = createMockBucket()
+    const state = createMockState()
+
+    const scheduler = createSnapshotScheduler({
+      bucket,
+      tablePath: 'iceberg',
+      state,
+    })
+
+    await scheduler.initialize()
+
+    await scheduler.schedule('table1', '0 * * * *')
+    await scheduler.schedule('table2', '0 0 * * *')
+    await scheduler.schedule('table3', '0 0 * * 0')
+
+    const schedules = scheduler.listScheduled()
+    expect(schedules).toHaveLength(3)
+  })
+
+  it('should persist state across restarts', async () => {
+    const bucket = createMockBucket()
+    const state = createMockState()
+
+    // First scheduler instance
+    const scheduler1 = createSnapshotScheduler({
+      bucket,
+      tablePath: 'iceberg',
+      state,
+    })
+
+    await scheduler1.initialize()
+    await scheduler1.schedule('test-table', '0 * * * *')
+    await scheduler1.setThreshold('test-table', 10000)
+
+    // Second scheduler instance (simulating restart)
+    const scheduler2 = createSnapshotScheduler({
+      bucket,
+      tablePath: 'iceberg',
+      state,
+    })
+
+    await scheduler2.initialize()
+
+    const schedules = scheduler2.listScheduled()
+    expect(schedules).toHaveLength(1)
+    expect(schedules[0]?.table).toBe('test-table')
+
+    const thresholds = scheduler2.listThresholds()
+    expect(thresholds).toHaveLength(1)
+    expect(thresholds[0]?.table).toBe('test-table')
+  })
+
+  it('should handle scheduler without Durable Object state', async () => {
+    const bucket = createMockBucket()
+
+    const scheduler = createSnapshotScheduler({
+      bucket,
+      tablePath: 'iceberg',
+      // No state provided
+    })
+
+    await scheduler.initialize()
+
+    // Should still work, just without persistence
+    await scheduler.schedule('test-table', '0 * * * *')
+
+    const schedules = scheduler.listScheduled()
+    expect(schedules).toHaveLength(1)
+  })
+})
+
+describe('Size Policy Management', () => {
+  let bucket: MockR2BucketWithStorage
+  let state: DurableObjectState
+  let scheduler: SnapshotScheduler
+
+  beforeEach(async () => {
+    bucket = createMockBucket()
+    state = createMockState()
+
+    scheduler = createSnapshotScheduler({
+      bucket,
+      tablePath: 'iceberg',
+      state,
+    })
+
+    await scheduler.initialize()
+  })
+
+  it('should set size policy', async () => {
+    const policy = await scheduler.setSizePolicy('test-table', 100 * 1024 * 1024) // 100 MB
+
+    expect(policy.table).toBe('test-table')
+    expect(policy.sizeThresholdBytes).toBe(100 * 1024 * 1024)
+    expect(policy.currentSizeBytes).toBe(0)
+    expect(policy.enabled).toBe(true)
+  })
+
+  it('should throw on invalid size threshold', async () => {
+    await expect(
+      scheduler.setSizePolicy('test-table', 0)
+    ).rejects.toThrow('Size threshold must be positive')
+
+    await expect(
+      scheduler.setSizePolicy('test-table', -100)
+    ).rejects.toThrow('Size threshold must be positive')
+  })
+
+  it('should increment size and trigger at threshold', async () => {
+    await scheduler.setSizePolicy('test-table', 1000)
+
+    const shouldSnapshot1 = await scheduler.incrementSize('test-table', 500)
+    expect(shouldSnapshot1).toBe(false)
+
+    const policy1 = scheduler.getSizePolicy('test-table')
+    expect(policy1?.currentSizeBytes).toBe(500)
+
+    const shouldSnapshot2 = await scheduler.incrementSize('test-table', 600)
+    expect(shouldSnapshot2).toBe(true)
+
+    // Counter should be reset
+    const policy2 = scheduler.getSizePolicy('test-table')
+    expect(policy2?.currentSizeBytes).toBe(0)
+    expect(policy2?.lastSnapshot).toBeDefined()
+  })
+
+  it('should remove size policy', async () => {
+    await scheduler.setSizePolicy('test-table', 1000)
+
+    const deleted = await scheduler.removeSizePolicy('test-table')
+    expect(deleted).toBe(true)
+
+    const policies = scheduler.listSizePolicies()
+    expect(policies).toHaveLength(0)
+  })
+
+  it('should list all size policies', async () => {
+    await scheduler.setSizePolicy('table1', 1000)
+    await scheduler.setSizePolicy('table2', 2000)
+
+    const policies = scheduler.listSizePolicies()
+    expect(policies).toHaveLength(2)
+  })
+
+  it('should ignore disabled size policies', async () => {
+    await scheduler.setSizePolicy('test-table', 100)
+
+    const policy = scheduler.getSizePolicy('test-table')
+    if (policy) {
+      policy.enabled = false
+    }
+
+    const shouldSnapshot = await scheduler.incrementSize('test-table', 200)
+    expect(shouldSnapshot).toBe(false)
+  })
+
+  it('should track size policy count in stats', async () => {
+    await scheduler.setSizePolicy('table1', 1000)
+    await scheduler.setSizePolicy('table2', 2000)
+
+    const stats = scheduler.getStats()
+    expect(stats.sizePolicyTablesCount).toBe(2)
+  })
+})
+
+describe('Lifecycle Policy Management', () => {
+  let bucket: MockR2BucketWithStorage
+  let state: DurableObjectState
+  let scheduler: SnapshotScheduler
+
+  beforeEach(async () => {
+    bucket = createMockBucket()
+    state = createMockState()
+
+    // Create test table metadata
+    const metadata = createTestMetadata()
+    bucket._storage.set('iceberg/test-table/metadata/version-hint.text', {
+      data: '1',
+      size: 1,
+      uploaded: new Date(),
+    })
+    bucket._storage.set('iceberg/test-table/metadata/v1.metadata.json', {
+      data: JSON.stringify(metadata),
+      size: JSON.stringify(metadata).length,
+      uploaded: new Date(),
+    })
+
+    scheduler = createSnapshotScheduler({
+      bucket,
+      tablePath: 'iceberg',
+      state,
+    })
+
+    await scheduler.initialize()
+  })
+
+  it('should set lifecycle policy with retention', async () => {
+    const policy = await scheduler.setLifecyclePolicy('test-table', {
+      maxAgeDays: 30,
+      minSnapshotsToRetain: 5,
+    })
+
+    expect(policy.table).toBe('test-table')
+    expect(policy.enabled).toBe(true)
+    expect(policy.retention.maxAgeDays).toBe(30)
+    expect(policy.retention.minSnapshotsToRetain).toBe(5)
+  })
+
+  it('should set lifecycle policy with expiration timestamp', async () => {
+    const expirationDate = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000) // 7 days from now
+
+    const policy = await scheduler.setLifecyclePolicy(
+      'test-table',
+      { maxAgeDays: 30 },
+      { expirationTimestamp: expirationDate.toISOString() }
+    )
+
+    expect(policy.expirationTimestamp).toBe(expirationDate.toISOString())
+  })
+
+  it('should set lifecycle policy with archive and delete days', async () => {
+    const policy = await scheduler.setLifecyclePolicy(
+      'test-table',
+      { maxAgeDays: 30 },
+      {
+        archiveAfterDays: 90,
+        deleteAfterDays: 365,
+      }
+    )
+
+    expect(policy.archiveAfterDays).toBe(90)
+    expect(policy.deleteAfterDays).toBe(365)
+  })
+
+  it('should remove lifecycle policy', async () => {
+    await scheduler.setLifecyclePolicy('test-table', { maxAgeDays: 30 })
+
+    const deleted = await scheduler.removeLifecyclePolicy('test-table')
+    expect(deleted).toBe(true)
+
+    const policies = scheduler.listLifecyclePolicies()
+    expect(policies).toHaveLength(0)
+  })
+
+  it('should toggle lifecycle policy enabled state', async () => {
+    await scheduler.setLifecyclePolicy('test-table', { maxAgeDays: 30 })
+
+    const disabled = await scheduler.toggleLifecyclePolicy('test-table', false)
+    expect(disabled?.enabled).toBe(false)
+
+    const enabled = await scheduler.toggleLifecyclePolicy('test-table', true)
+    expect(enabled?.enabled).toBe(true)
+  })
+
+  it('should list all lifecycle policies', async () => {
+    await scheduler.setLifecyclePolicy('table1', { maxAgeDays: 30 })
+    await scheduler.setLifecyclePolicy('table2', { maxAgeDays: 60 })
+
+    const policies = scheduler.listLifecyclePolicies()
+    expect(policies).toHaveLength(2)
+  })
+
+  it('should track lifecycle policy count in stats', async () => {
+    await scheduler.setLifecyclePolicy('table1', { maxAgeDays: 30 })
+    await scheduler.setLifecyclePolicy('table2', { maxAgeDays: 60 })
+
+    const stats = scheduler.getStats()
+    expect(stats.lifecyclePolicyTablesCount).toBe(2)
+  })
+
+  it('should return error when enforcing non-existent policy', async () => {
+    const result = await scheduler.enforceLifecyclePolicy('non-existent')
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('not found or disabled')
+  })
+
+  it('should return error when enforcing disabled policy', async () => {
+    await scheduler.setLifecyclePolicy('test-table', { maxAgeDays: 30 })
+    await scheduler.toggleLifecyclePolicy('test-table', false)
+
+    const result = await scheduler.enforceLifecyclePolicy('test-table')
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('not found or disabled')
+  })
+})
+
+describe('Advanced Cron Expressions', () => {
+  it('should parse cron with comma-separated values (0,30 * * * *)', () => {
+    const now = new Date('2024-01-15T10:05:00Z')
+    const next = parseNextRun('0,30 * * * *', now)
+
+    // Should be at minute 30 (the first valid minute after 05)
+    expect(next.getMinutes()).toBe(30)
+    // Hour depends on local timezone, so just verify it's in the future
+    expect(next.getTime()).toBeGreaterThan(now.getTime())
+  })
+
+  it('should parse cron with range (0-15 * * * *)', () => {
+    const now = new Date('2024-01-15T10:20:00Z')
+    const next = parseNextRun('0-15 * * * *', now)
+
+    // Should be at minute 0 of the next hour (local time)
+    expect(next.getMinutes()).toBe(0)
+    // Verify it's in the future
+    expect(next.getTime()).toBeGreaterThan(now.getTime())
+  })
+
+  it('should parse step values for hours (0 */2 * * *)', () => {
+    const now = new Date('2024-01-15T09:30:00Z')
+    const next = parseNextRun('0 */2 * * *', now)
+
+    expect(next.getMinutes()).toBe(0)
+    // Hour should be even (0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22)
+    expect(next.getHours() % 2).toBe(0)
+    // Verify it's in the future
+    expect(next.getTime()).toBeGreaterThan(now.getTime())
+  })
+
+  it('should parse specific day of month (0 0 15 * *)', () => {
+    const now = new Date('2024-01-10T10:00:00Z')
+    const next = parseNextRun('0 0 15 * *', now)
+
+    expect(next.getDate()).toBe(15)
+    expect(next.getHours()).toBe(0)
+    expect(next.getMinutes()).toBe(0)
+  })
+
+  it('should parse specific month (0 0 1 6 *)', () => {
+    const now = new Date('2024-01-15T10:00:00Z')
+    const next = parseNextRun('0 0 1 6 *', now)
+
+    expect(next.getMonth()).toBe(5) // June (0-indexed)
+    expect(next.getDate()).toBe(1)
+  })
+
+  it('should handle leap year correctly', () => {
+    const now = new Date('2024-02-28T10:00:00Z')
+    const next = parseNextRun('0 0 29 2 *', now)
+
+    expect(next.getDate()).toBe(29)
+    expect(next.getMonth()).toBe(1) // February
+    expect(next.getFullYear()).toBe(2024)
+  })
+
+  it('should handle combination of day and day of week (0 0 1 * 0)', () => {
+    // This tests when both day of month and day of week are specified
+    const now = new Date('2024-01-01T10:00:00Z') // Monday
+    const next = parseNextRun('0 0 * * 0', now) // Every Sunday
+
+    expect(next.getDay()).toBe(0) // Sunday
+  })
+})
+
+describe('Scheduler State Persistence', () => {
+  it('should persist size policies across restarts', async () => {
+    const bucket = createMockBucket()
+    const state = createMockState()
+
+    // First scheduler instance
+    const scheduler1 = createSnapshotScheduler({
+      bucket,
+      tablePath: 'iceberg',
+      state,
+    })
+
+    await scheduler1.initialize()
+    await scheduler1.setSizePolicy('test-table', 100 * 1024 * 1024)
+    await scheduler1.incrementSize('test-table', 50 * 1024 * 1024)
+
+    // Second scheduler instance (simulating restart)
+    const scheduler2 = createSnapshotScheduler({
+      bucket,
+      tablePath: 'iceberg',
+      state,
+    })
+
+    await scheduler2.initialize()
+
+    const policies = scheduler2.listSizePolicies()
+    expect(policies).toHaveLength(1)
+    expect(policies[0]?.table).toBe('test-table')
+    expect(policies[0]?.currentSizeBytes).toBe(50 * 1024 * 1024)
+  })
+
+  it('should persist lifecycle policies across restarts', async () => {
+    const bucket = createMockBucket()
+    const state = createMockState()
+
+    // First scheduler instance
+    const scheduler1 = createSnapshotScheduler({
+      bucket,
+      tablePath: 'iceberg',
+      state,
+    })
+
+    await scheduler1.initialize()
+    await scheduler1.setLifecyclePolicy('test-table', {
+      maxAgeDays: 30,
+      minSnapshotsToRetain: 5,
+    }, {
+      archiveAfterDays: 90,
+    })
+
+    // Second scheduler instance (simulating restart)
+    const scheduler2 = createSnapshotScheduler({
+      bucket,
+      tablePath: 'iceberg',
+      state,
+    })
+
+    await scheduler2.initialize()
+
+    const policies = scheduler2.listLifecyclePolicies()
+    expect(policies).toHaveLength(1)
+    expect(policies[0]?.table).toBe('test-table')
+    expect(policies[0]?.retention.maxAgeDays).toBe(30)
+    expect(policies[0]?.archiveAfterDays).toBe(90)
+  })
+})
+
+describe('Statistics Tracking', () => {
+  let bucket: MockR2BucketWithStorage
+  let state: DurableObjectState
+  let scheduler: SnapshotScheduler
+
+  beforeEach(async () => {
+    bucket = createMockBucket()
+    state = createMockState()
+
+    scheduler = createSnapshotScheduler({
+      bucket,
+      tablePath: 'iceberg',
+      state,
+    })
+
+    await scheduler.initialize()
+  })
+
+  it('should track all policy counts correctly', async () => {
+    await scheduler.schedule('table1', '0 * * * *')
+    await scheduler.schedule('table2', '0 0 * * *')
+    await scheduler.setThreshold('table3', 10000)
+    await scheduler.setSizePolicy('table4', 100 * 1024 * 1024)
+    await scheduler.setLifecyclePolicy('table5', { maxAgeDays: 30 })
+
+    const stats = scheduler.getStats()
+    expect(stats.scheduledTablesCount).toBe(2)
+    expect(stats.thresholdTablesCount).toBe(1)
+    expect(stats.sizePolicyTablesCount).toBe(1)
+    expect(stats.lifecyclePolicyTablesCount).toBe(1)
+  })
+
+  it('should reset all statistics correctly', async () => {
+    await scheduler.schedule('table1', '0 * * * *')
+    await scheduler.setThreshold('table2', 10000)
+    await scheduler.setSizePolicy('table3', 100 * 1024 * 1024)
+    await scheduler.setLifecyclePolicy('table4', { maxAgeDays: 30 })
+
+    await scheduler.resetStats()
+
+    const stats = scheduler.getStats()
+    expect(stats.scheduledSnapshotsCreated).toBe(0)
+    expect(stats.thresholdSnapshotsCreated).toBe(0)
+    expect(stats.sizeSnapshotsCreated).toBe(0)
+    expect(stats.retentionEnforcements).toBe(0)
+    expect(stats.lifecycleEnforcements).toBe(0)
+    expect(stats.lastRunAt).toBeNull()
+    expect(stats.lastSnapshotAt).toBeNull()
+    // Counts should reflect current policies
+    expect(stats.scheduledTablesCount).toBe(1)
+    expect(stats.thresholdTablesCount).toBe(1)
+    expect(stats.sizePolicyTablesCount).toBe(1)
+    expect(stats.lifecyclePolicyTablesCount).toBe(1)
+  })
+})