@dotdo/postgres 0.1.0

package/src/storage/tiered-vfs-swr.test.ts

@@ -0,0 +1,736 @@
+/**
+ * Tests for TieredVFSWithSWR - TieredVFS with Stale-While-Revalidate Cache Integration
+ * Issue: postgres-kpa8 - Cache Layer SWR Integration
+ *
+ * Tests the SWR integration with TieredVFS:
+ * - Fresh cache hits return immediately
+ * - Stale cache hits return data + trigger background revalidation
+ * - Cache misses fall through to warm/cold tiers
+ * - SWR stats are tracked correctly
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import {
+  TieredVFSWithSWR,
+  TieredVFSWithSWRConfig,
+  createTieredVFSWithSWR,
+  TieredVFSSWRStats,
+} from './tiered-vfs-swr'
+import type { CacheLayer } from './cache-layer'
+import type { R2StorageLayer } from './r2-layer'
+import type { SWRCacheLayer, SWRResult, ExecutionContext } from './swr-cache'
+
+// Mock CacheLayer
+const createMockCacheLayer = () => ({
+  get: vi.fn(),
+  put: vi.fn(),
+  delete: vi.fn(),
+  has: vi.fn(),
+  getWithMetadata: vi.fn(),
+  getStats: vi.fn().mockReturnValue({
+    hits: 0,
+    misses: 0,
+    writes: 0,
+    deletes: 0,
+    bytesRead: 0,
+    bytesWritten: 0,
+    errors: 0,
+    hitRatio: 0,
+  }),
+  clear: vi.fn(),
+  resetStats: vi.fn(),
+  getConfig: vi.fn(),
+})
+
+// Mock DOStorage (Durable Object storage simulation)
+const createMockDOStorage = () => ({
+  get: vi.fn(),
+  put: vi.fn().mockResolvedValue(undefined),
+  delete: vi.fn().mockResolvedValue(undefined),
+  list: vi.fn(),
+})
+
+// Mock R2StorageLayer
+const createMockR2Layer = () => ({
+  get: vi.fn(),
+  getRange: vi.fn(),
+  put: vi.fn(),
+  delete: vi.fn(),
+  deleteMany: vi.fn(),
+  head: vi.fn(),
+  has: vi.fn(),
+  list: vi.fn(),
+  getStats: vi.fn().mockReturnValue({
+    reads: 0,
+    rangeReads: 0,
+    writes: 0,
+    deletes: 0,
+    bytesRead: 0,
+    bytesWritten: 0,
+    errors: 0,
+    headRequests: 0,
+    listRequests: 0,
+  }),
+  resetStats: vi.fn(),
+  getPrefix: vi.fn(),
+})
+
+// Mock SWRCacheLayer
+const createMockSWRCacheLayer = () => ({
+  get: vi.fn(),
+  put: vi.fn(),
+  invalidate: vi.fn(),
+  has: vi.fn(),
+  setOriginFetcher: vi.fn(),
+  getStats: vi.fn().mockReturnValue({
+    primaryHits: 0,
+    staleHits: 0,
+    misses: 0,
+    revalidations: 0,
+    writes: 0,
+    invalidations: 0,
+    bytesRead: 0,
+    bytesWritten: 0,
+    errors: 0,
+    primaryHitRatio: 0,
+    combinedHitRatio: 0,
+  }),
+  resetStats: vi.fn(),
+  getConfig: vi.fn(),
+})
+
+// Mock ExecutionContext
+const createMockExecutionContext = (): ExecutionContext => ({
+  waitUntil: vi.fn(),
+})
+
+describe('TieredVFSWithSWR - SWR Cache Integration', () => {
+  let mockCacheLayer: ReturnType<typeof createMockCacheLayer>
+  let mockDOStorage: ReturnType<typeof createMockDOStorage>
+  let mockR2Layer: ReturnType<typeof createMockR2Layer>
+  let mockSWRCacheLayer: ReturnType<typeof createMockSWRCacheLayer>
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockCacheLayer = createMockCacheLayer()
+    mockDOStorage = createMockDOStorage()
+    mockR2Layer = createMockR2Layer()
+    mockSWRCacheLayer = createMockSWRCacheLayer()
+  })
+
+  describe('TieredVFSWithSWRConfig', () => {
+    it('should have required config fields', () => {
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      expect(config.cacheLayer).toBeDefined()
+      expect(config.doStorage).toBeDefined()
+      expect(config.r2Layer).toBeDefined()
+      expect(config.swrCacheLayer).toBeDefined()
+      expect(config.pageSize).toBe(8192)
+    })
+
+    it('should support optional promotion threshold', () => {
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+        promotionThreshold: 5,
+      }
+      expect(config.promotionThreshold).toBe(5)
+    })
+
+    it('should support optional autoPromote flag', () => {
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+        autoPromote: true,
+      }
+      expect(config.autoPromote).toBe(true)
+    })
+  })
+
+  describe('createTieredVFSWithSWR()', () => {
+    it('should return a TieredVFSWithSWR instance', () => {
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+      expect(vfs).toBeDefined()
+      expect(vfs).toBeInstanceOf(TieredVFSWithSWR)
+    })
+
+    it('should wire R2 as origin fetcher for SWR', () => {
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      createTieredVFSWithSWR(config)
+      expect(mockSWRCacheLayer.setOriginFetcher).toHaveBeenCalled()
+    })
+  })
+
+  describe('readPage() - SWR Fresh Cache Hit', () => {
+    it('should return fresh data immediately from SWR primary cache', async () => {
+      const data = new Uint8Array([1, 2, 3, 4, 5])
+      const swrResult: SWRResult = {
+        data,
+        hit: true,
+        stale: false,
+        revalidating: false,
+      }
+      mockSWRCacheLayer.get.mockResolvedValue(swrResult)
+
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+
+      const result = await vfs.readPage('page-123')
+      expect(result).toEqual(data)
+      expect(mockSWRCacheLayer.get).toHaveBeenCalledWith('page-123', undefined)
+      expect(mockDOStorage.get).not.toHaveBeenCalled()
+      expect(mockR2Layer.get).not.toHaveBeenCalled()
+    })
+
+    it('should track fresh cache hit in SWR stats', async () => {
+      const data = new Uint8Array([1, 2, 3])
+      const swrResult: SWRResult = {
+        data,
+        hit: true,
+        stale: false,
+        revalidating: false,
+      }
+      mockSWRCacheLayer.get.mockResolvedValue(swrResult)
+
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+
+      await vfs.readPage('page-123')
+
+      const stats = vfs.getStats()
+      expect(stats.swr.freshCacheHits).toBe(1)
+      expect(stats.swr.staleCacheHits).toBe(0)
+      expect(stats.swr.backgroundRevalidations).toBe(0)
+    })
+  })
+
+  describe('readPage() - SWR Stale Cache Hit', () => {
+    it('should return stale data and track stale hit', async () => {
+      const data = new Uint8Array([10, 20, 30])
+      const swrResult: SWRResult = {
+        data,
+        hit: true,
+        stale: true,
+        revalidating: false,
+      }
+      mockSWRCacheLayer.get.mockResolvedValue(swrResult)
+
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+
+      const result = await vfs.readPage('page-123')
+      expect(result).toEqual(data)
+
+      const stats = vfs.getStats()
+      expect(stats.swr.staleCacheHits).toBe(1)
+      expect(stats.swr.freshCacheHits).toBe(0)
+    })
+
+    it('should track background revalidation when triggered', async () => {
+      const data = new Uint8Array([10, 20, 30])
+      const swrResult: SWRResult = {
+        data,
+        hit: true,
+        stale: true,
+        revalidating: true, // Background revalidation was triggered
+      }
+      mockSWRCacheLayer.get.mockResolvedValue(swrResult)
+
+      const ctx = createMockExecutionContext()
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+
+      await vfs.readPage('page-123', { ctx })
+
+      const stats = vfs.getStats()
+      expect(stats.swr.staleCacheHits).toBe(1)
+      expect(stats.swr.backgroundRevalidations).toBe(1)
+    })
+
+    it('should pass execution context to SWR cache for background revalidation', async () => {
+      const swrResult: SWRResult = {
+        data: new Uint8Array([1, 2, 3]),
+        hit: true,
+        stale: true,
+        revalidating: true,
+      }
+      mockSWRCacheLayer.get.mockResolvedValue(swrResult)
+
+      const ctx = createMockExecutionContext()
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+
+      await vfs.readPage('page-123', { ctx })
+
+      expect(mockSWRCacheLayer.get).toHaveBeenCalledWith('page-123', ctx)
+    })
+  })
+
+  describe('readPage() - SWR Cache Miss', () => {
+    it('should fall back to DO storage on SWR cache miss', async () => {
+      const swrResult: SWRResult = {
+        data: null,
+        hit: false,
+        stale: false,
+        revalidating: false,
+      }
+      mockSWRCacheLayer.get.mockResolvedValue(swrResult)
+
+      const data = new Uint8Array([100, 200])
+      mockDOStorage.get.mockResolvedValue(data)
+
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+
+      const result = await vfs.readPage('page-123')
+      expect(result).toEqual(data)
+      expect(mockDOStorage.get).toHaveBeenCalledWith('page-123')
+    })
+
+    it('should populate SWR cache after warm tier hit', async () => {
+      const swrResult: SWRResult = {
+        data: null,
+        hit: false,
+        stale: false,
+        revalidating: false,
+      }
+      mockSWRCacheLayer.get.mockResolvedValue(swrResult)
+
+      const data = new Uint8Array([100, 200])
+      mockDOStorage.get.mockResolvedValue(data)
+
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+
+      await vfs.readPage('page-123')
+
+      expect(mockSWRCacheLayer.put).toHaveBeenCalledWith('page-123', data)
+    })
+
+    it('should fall back to R2 and populate SWR cache', async () => {
+      const swrResult: SWRResult = {
+        data: null,
+        hit: false,
+        stale: false,
+        revalidating: false,
+      }
+      mockSWRCacheLayer.get.mockResolvedValue(swrResult)
+      mockDOStorage.get.mockResolvedValue(undefined)
+
+      const data = new Uint8Array([50, 60, 70])
+      mockR2Layer.get.mockResolvedValue(data)
+
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+
+      const result = await vfs.readPage('page-123')
+      expect(result).toEqual(data)
+      expect(mockSWRCacheLayer.put).toHaveBeenCalledWith('page-123', data)
+    })
+
+    it('should return null when page not found in any tier', async () => {
+      const swrResult: SWRResult = {
+        data: null,
+        hit: false,
+        stale: false,
+        revalidating: false,
+      }
+      mockSWRCacheLayer.get.mockResolvedValue(swrResult)
+      mockDOStorage.get.mockResolvedValue(undefined)
+      mockR2Layer.get.mockResolvedValue(null)
+
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+
+      const result = await vfs.readPage('nonexistent')
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('readPageWithLocation()', () => {
+    it('should return hot tier with stale flag for stale SWR hit', async () => {
+      const data = new Uint8Array([1, 2, 3])
+      const swrResult: SWRResult = {
+        data,
+        hit: true,
+        stale: true,
+        revalidating: true,
+      }
+      mockSWRCacheLayer.get.mockResolvedValue(swrResult)
+
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+
+      const result = await vfs.readPageWithLocation('page-123')
+      expect(result?.tier).toBe('hot')
+      expect(result?.stale).toBe(true)
+    })
+
+    it('should return hot tier without stale flag for fresh SWR hit', async () => {
+      const data = new Uint8Array([1, 2, 3])
+      const swrResult: SWRResult = {
+        data,
+        hit: true,
+        stale: false,
+        revalidating: false,
+      }
+      mockSWRCacheLayer.get.mockResolvedValue(swrResult)
+
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+
+      const result = await vfs.readPageWithLocation('page-123')
+      expect(result?.tier).toBe('hot')
+      expect(result?.stale).toBe(false)
+    })
+  })
+
+  describe('writePage()', () => {
+    it('should update SWR cache on warm tier write', async () => {
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+
+      const data = new Uint8Array([1, 2, 3])
+      await vfs.writePage('page-456', data)
+
+      expect(mockDOStorage.put).toHaveBeenCalledWith('page-456', data)
+      expect(mockSWRCacheLayer.put).toHaveBeenCalledWith('page-456', data)
+    })
+
+    it('should update both caches on hot tier write', async () => {
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+
+      const data = new Uint8Array([1, 2, 3])
+      await vfs.writePage('page-456', data, { tier: 'hot' })
+
+      expect(mockDOStorage.put).toHaveBeenCalledWith('page-456', data)
+      expect(mockCacheLayer.put).toHaveBeenCalled()
+      expect(mockSWRCacheLayer.put).toHaveBeenCalledWith('page-456', data)
+    })
+
+    it('should invalidate SWR cache on cold tier write', async () => {
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+
+      const data = new Uint8Array([1, 2, 3])
+      await vfs.writePage('page-456', data, { tier: 'cold' })
+
+      expect(mockR2Layer.put).toHaveBeenCalled()
+      expect(mockSWRCacheLayer.invalidate).toHaveBeenCalledWith('page-456')
+    })
+  })
+
+  describe('deletePage()', () => {
+    it('should invalidate SWR cache on delete', async () => {
+      mockCacheLayer.delete.mockResolvedValue(true)
+      mockR2Layer.delete.mockResolvedValue(undefined)
+
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+
+      await vfs.deletePage('page-789')
+
+      expect(mockSWRCacheLayer.invalidate).toHaveBeenCalledWith('page-789')
+      expect(mockCacheLayer.delete).toHaveBeenCalledWith('page-789')
+      expect(mockDOStorage.delete).toHaveBeenCalledWith('page-789')
+      expect(mockR2Layer.delete).toHaveBeenCalledWith('page-789')
+    })
+  })
+
+  describe('locatePage()', () => {
+    it('should check SWR cache for hot tier', async () => {
+      mockSWRCacheLayer.has.mockResolvedValue(true)
+
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+
+      const location = await vfs.locatePage('page-123')
+      expect(location.tier).toBe('hot')
+      expect(location.found).toBe(true)
+    })
+
+    it('should fall back to standard cache check', async () => {
+      mockSWRCacheLayer.has.mockResolvedValue(false)
+      mockCacheLayer.has.mockResolvedValue(true)
+
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+
+      const location = await vfs.locatePage('page-123')
+      expect(location.tier).toBe('hot')
+      expect(location.found).toBe(true)
+    })
+  })
+
+  describe('getStats()', () => {
+    it('should include SWR stats in combined stats', () => {
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+
+      const stats = vfs.getStats()
+      expect(stats.swr).toBeDefined()
+      expect(stats.swr.enabled).toBe(true)
+      expect(stats.swr.freshCacheHits).toBe(0)
+      expect(stats.swr.staleCacheHits).toBe(0)
+      expect(stats.swr.backgroundRevalidations).toBe(0)
+    })
+  })
+
+  describe('getSWRStats()', () => {
+    it('should return SWR-specific stats', async () => {
+      const data = new Uint8Array([1, 2, 3])
+
+      // First call - fresh hit
+      mockSWRCacheLayer.get.mockResolvedValueOnce({
+        data,
+        hit: true,
+        stale: false,
+        revalidating: false,
+      })
+
+      // Second call - stale hit with revalidation
+      mockSWRCacheLayer.get.mockResolvedValueOnce({
+        data,
+        hit: true,
+        stale: true,
+        revalidating: true,
+      })
+
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+
+      await vfs.readPage('page-1')
+      await vfs.readPage('page-2')
+
+      const swrStats = vfs.getSWRStats()
+      expect(swrStats.freshCacheHits).toBe(1)
+      expect(swrStats.staleCacheHits).toBe(1)
+      expect(swrStats.backgroundRevalidations).toBe(1)
+      expect(swrStats.enabled).toBe(true)
+    })
+  })
+
+  describe('resetStats()', () => {
+    it('should reset SWR stats', async () => {
+      const data = new Uint8Array([1, 2, 3])
+      mockSWRCacheLayer.get.mockResolvedValue({
+        data,
+        hit: true,
+        stale: false,
+        revalidating: false,
+      })
+
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+
+      await vfs.readPage('page-123')
+      expect(vfs.getSWRStats().freshCacheHits).toBe(1)
+
+      vfs.resetStats()
+      expect(vfs.getSWRStats().freshCacheHits).toBe(0)
+      expect(mockSWRCacheLayer.resetStats).toHaveBeenCalled()
+    })
+  })
+
+  describe('isSWREnabled()', () => {
+    it('should always return true for TieredVFSWithSWR', () => {
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+
+      expect(vfs.isSWREnabled()).toBe(true)
+    })
+  })
+
+  describe('Promotion with SWR', () => {
+    it('should update both caches when promoting to hot', async () => {
+      const data = new Uint8Array([1, 2, 3])
+      mockDOStorage.get.mockResolvedValue(data)
+
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+
+      await vfs.promoteToHot('page-123')
+
+      expect(mockCacheLayer.put).toHaveBeenCalled()
+      expect(mockSWRCacheLayer.put).toHaveBeenCalledWith('page-123', data)
+    })
+  })
+
+  describe('Demotion with SWR', () => {
+    it('should invalidate SWR cache when demoting from hot', async () => {
+      mockCacheLayer.delete.mockResolvedValue(true)
+
+      const config: TieredVFSWithSWRConfig = {
+        cacheLayer: mockCacheLayer as unknown as CacheLayer,
+        doStorage: mockDOStorage as unknown as DurableObjectStorage,
+        r2Layer: mockR2Layer as unknown as R2StorageLayer,
+        swrCacheLayer: mockSWRCacheLayer as unknown as SWRCacheLayer,
+        pageSize: 8192,
+      }
+      const vfs = createTieredVFSWithSWR(config)
+
+      await vfs.demoteFromHot('page-123')
+
+      expect(mockCacheLayer.delete).toHaveBeenCalledWith('page-123')
+      expect(mockSWRCacheLayer.invalidate).toHaveBeenCalledWith('page-123')
+    })
+  })
+})