@dotdo/postgres 0.1.0

package/src/pglite/etag-cache.test.ts

@@ -0,0 +1,844 @@
+/**
+ * Tests for ETag-based Cache Invalidation Strategy
+ * Task: postgres-1ac - Arch: Implement cache invalidation strategy with ETags
+ *
+ * These tests verify the ETag generation, parsing, and cache invalidation functionality.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import {
+  hashQueryResult,
+  generateETag,
+  parseETag,
+  parseIfNoneMatch,
+  etagMatches,
+  extractTablesFromQuery,
+  isWriteQuery,
+  ETagCache,
+  createETagCache,
+  createETagHeaders,
+  createNotModifiedResponse,
+  type ETagCacheConfig,
+  type CachedQueryResult,
+  type ConditionalResult,
+  type ETagCacheStats,
+} from './etag-cache'
+
+// Mock the Cloudflare Cache API
+const mockCache = {
+  match: vi.fn(),
+  put: vi.fn(),
+  delete: vi.fn(),
+}
+
+const mockCaches = {
+  open: vi.fn().mockResolvedValue(mockCache),
+  default: mockCache,
+}
+
+// Polyfill global caches for testing
+;(globalThis as any).caches = mockCaches
+
+describe('ETag Cache Invalidation Strategy', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockCache.match.mockReset()
+    mockCache.put.mockReset()
+    mockCache.delete.mockReset()
+    mockCaches.open.mockResolvedValue(mockCache)
+  })
+
+  describe('hashQueryResult()', () => {
+    it('should generate a hash from query result data', async () => {
+      const data = { rows: [{ id: 1, name: 'test' }] }
+      const hash = await hashQueryResult(data)
+
+      expect(hash).toBeDefined()
+      expect(typeof hash).toBe('string')
+      expect(hash.length).toBe(16) // Returns first 16 hex chars
+    })
+
+    it('should generate consistent hashes for same data', async () => {
+      const data = { rows: [{ id: 1 }] }
+
+      const hash1 = await hashQueryResult(data)
+      const hash2 = await hashQueryResult(data)
+
+      expect(hash1).toBe(hash2)
+    })
+
+    it('should generate different hashes for different data', async () => {
+      const data1 = { rows: [{ id: 1 }] }
+      const data2 = { rows: [{ id: 2 }] }
+
+      const hash1 = await hashQueryResult(data1)
+      const hash2 = await hashQueryResult(data2)
+
+      expect(hash1).not.toBe(hash2)
+    })
+
+    it('should handle empty arrays', async () => {
+      const data = { rows: [] }
+      const hash = await hashQueryResult(data)
+
+      expect(hash).toBeDefined()
+      expect(hash.length).toBe(16)
+    })
+
+    it('should handle complex nested data', async () => {
+      const data = {
+        rows: [
+          { id: 1, data: { nested: { value: 123 } }, array: [1, 2, 3] },
+        ],
+      }
+      const hash = await hashQueryResult(data)
+
+      expect(hash).toBeDefined()
+      expect(hash.length).toBe(16)
+    })
+  })
+
+  describe('generateETag()', () => {
+    it('should generate a strong ETag by default', async () => {
+      const data = { rows: [{ id: 1 }] }
+      const etag = await generateETag(data)
+
+      expect(etag).toMatch(/^"[a-f0-9]{16}"$/)
+    })
+
+    it('should generate a weak ETag when specified', async () => {
+      const data = { rows: [{ id: 1 }] }
+      const etag = await generateETag(data, true)
+
+      expect(etag).toMatch(/^W\/"[a-f0-9]{16}"$/)
+    })
+
+    it('should generate consistent ETags for same data', async () => {
+      const data = { rows: [{ id: 1 }] }
+
+      const etag1 = await generateETag(data)
+      const etag2 = await generateETag(data)
+
+      expect(etag1).toBe(etag2)
+    })
+  })
+
+  describe('parseETag()', () => {
+    it('should parse a strong ETag', () => {
+      const result = parseETag('"abc123def456"')
+
+      expect(result).toEqual({ hash: 'abc123def456', weak: false })
+    })
+
+    it('should parse a weak ETag', () => {
+      const result = parseETag('W/"abc123def456"')
+
+      expect(result).toEqual({ hash: 'abc123def456', weak: true })
+    })
+
+    it('should handle whitespace', () => {
+      const result = parseETag('  "abc123"  ')
+
+      expect(result).toEqual({ hash: 'abc123', weak: false })
+    })
+
+    it('should return null for invalid ETags', () => {
+      expect(parseETag('')).toBeNull()
+      expect(parseETag('abc123')).toBeNull()
+      expect(parseETag('W/abc123')).toBeNull()
+    })
+
+    it('should return null for empty input', () => {
+      expect(parseETag('')).toBeNull()
+    })
+  })
+
+  describe('parseIfNoneMatch()', () => {
+    it('should parse a single ETag', () => {
+      const result = parseIfNoneMatch('"abc123"')
+
+      expect(result).toEqual([{ hash: 'abc123', weak: false }])
+    })
+
+    it('should parse multiple ETags', () => {
+      const result = parseIfNoneMatch('"abc123", "def456", W/"ghi789"')
+
+      expect(result).toEqual([
+        { hash: 'abc123', weak: false },
+        { hash: 'def456', weak: false },
+        { hash: 'ghi789', weak: true },
+      ])
+    })
+
+    it('should handle wildcard', () => {
+      const result = parseIfNoneMatch('*')
+
+      expect(result).toEqual([{ hash: '*', weak: false }])
+    })
+
+    it('should return empty array for empty input', () => {
+      expect(parseIfNoneMatch('')).toEqual([])
+    })
+
+    it('should skip invalid ETags in list', () => {
+      const result = parseIfNoneMatch('"valid", invalid, "also-valid"')
+
+      expect(result).toEqual([
+        { hash: 'valid', weak: false },
+        { hash: 'also-valid', weak: false },
+      ])
+    })
+  })
+
+  describe('etagMatches()', () => {
+    it('should return true for matching ETags', () => {
+      const etag = '"abc123"'
+      const ifNoneMatch = parseIfNoneMatch('"abc123"')
+
+      expect(etagMatches(etag, ifNoneMatch)).toBe(true)
+    })
+
+    it('should return true for wildcard', () => {
+      const etag = '"abc123"'
+      const ifNoneMatch = parseIfNoneMatch('*')
+
+      expect(etagMatches(etag, ifNoneMatch)).toBe(true)
+    })
+
+    it('should return true when ETag is in list', () => {
+      const etag = '"def456"'
+      const ifNoneMatch = parseIfNoneMatch('"abc123", "def456", "ghi789"')
+
+      expect(etagMatches(etag, ifNoneMatch)).toBe(true)
+    })
+
+    it('should return false for non-matching ETags', () => {
+      const etag = '"xyz999"'
+      const ifNoneMatch = parseIfNoneMatch('"abc123", "def456"')
+
+      expect(etagMatches(etag, ifNoneMatch)).toBe(false)
+    })
+
+    it('should return false for empty If-None-Match list', () => {
+      const etag = '"abc123"'
+
+      expect(etagMatches(etag, [])).toBe(false)
+    })
+
+    it('should match weak and strong ETags with same hash', () => {
+      const strongEtag = '"abc123"'
+      const weakIfNoneMatch = parseIfNoneMatch('W/"abc123"')
+
+      expect(etagMatches(strongEtag, weakIfNoneMatch)).toBe(true)
+    })
+  })
+
+  describe('extractTablesFromQuery()', () => {
+    it('should extract tables from SELECT...FROM', () => {
+      const sql = 'SELECT * FROM users'
+      const tables = extractTablesFromQuery(sql)
+
+      expect(tables).toContain('users')
+    })
+
+    it('should extract multiple tables from FROM clause', () => {
+      const sql = 'SELECT * FROM users, orders, products'
+      const tables = extractTablesFromQuery(sql)
+
+      expect(tables).toContain('users')
+      expect(tables).toContain('orders')
+      expect(tables).toContain('products')
+    })
+
+    it('should extract tables from JOIN clauses', () => {
+      const sql = 'SELECT * FROM users JOIN orders ON users.id = orders.user_id'
+      const tables = extractTablesFromQuery(sql)
+
+      expect(tables).toContain('users')
+      expect(tables).toContain('orders')
+    })
+
+    it('should extract table from INSERT INTO', () => {
+      const sql = 'INSERT INTO users (name) VALUES ($1)'
+      const tables = extractTablesFromQuery(sql)
+
+      expect(tables).toContain('users')
+    })
+
+    it('should extract table from UPDATE', () => {
+      const sql = 'UPDATE users SET name = $1 WHERE id = $2'
+      const tables = extractTablesFromQuery(sql)
+
+      expect(tables).toContain('users')
+    })
+
+    it('should extract table from DELETE FROM', () => {
+      const sql = 'DELETE FROM users WHERE id = $1'
+      const tables = extractTablesFromQuery(sql)
+
+      expect(tables).toContain('users')
+    })
+
+    it('should be case-insensitive', () => {
+      const sql = 'SELECT * FROM Users JOIN Orders ON users.id = orders.user_id'
+      const tables = extractTablesFromQuery(sql)
+
+      expect(tables.length).toBe(2)
+    })
+
+    it('should handle underscored table names', () => {
+      const sql = 'SELECT * FROM user_accounts JOIN order_items'
+      const tables = extractTablesFromQuery(sql)
+
+      expect(tables).toContain('user_accounts')
+      expect(tables).toContain('order_items')
+    })
+  })
+
+  describe('isWriteQuery()', () => {
+    it('should return true for INSERT', () => {
+      expect(isWriteQuery('INSERT INTO users (name) VALUES ($1)')).toBe(true)
+    })
+
+    it('should return true for UPDATE', () => {
+      expect(isWriteQuery('UPDATE users SET name = $1')).toBe(true)
+    })
+
+    it('should return true for DELETE', () => {
+      expect(isWriteQuery('DELETE FROM users WHERE id = $1')).toBe(true)
+    })
+
+    it('should return true for TRUNCATE', () => {
+      expect(isWriteQuery('TRUNCATE TABLE users')).toBe(true)
+    })
+
+    it('should return true for DROP', () => {
+      expect(isWriteQuery('DROP TABLE users')).toBe(true)
+    })
+
+    it('should return true for ALTER', () => {
+      expect(isWriteQuery('ALTER TABLE users ADD COLUMN email TEXT')).toBe(true)
+    })
+
+    it('should return true for CREATE', () => {
+      expect(isWriteQuery('CREATE TABLE users (id INT)')).toBe(true)
+    })
+
+    it('should return false for SELECT', () => {
+      expect(isWriteQuery('SELECT * FROM users')).toBe(false)
+    })
+
+    it('should handle leading whitespace', () => {
+      expect(isWriteQuery('  INSERT INTO users VALUES (1)')).toBe(true)
+      expect(isWriteQuery('  SELECT * FROM users')).toBe(false)
+    })
+
+    it('should be case-insensitive', () => {
+      expect(isWriteQuery('insert INTO users VALUES (1)')).toBe(true)
+      expect(isWriteQuery('INSERT INTO users VALUES (1)')).toBe(true)
+    })
+  })
+
+  describe('ETagCache class', () => {
+    const defaultConfig: ETagCacheConfig = {
+      cacheName: 'test-etag-cache',
+      ttlSeconds: 3600,
+      baseUrl: 'https://etag.cache.local',
+      useWeakETags: false,
+    }
+
+    describe('constructor', () => {
+      it('should create an ETagCache instance', async () => {
+        const cache = await createETagCache(defaultConfig)
+
+        expect(cache).toBeDefined()
+        expect(cache).toBeInstanceOf(ETagCache)
+      })
+
+      it('should open the named cache', async () => {
+        await createETagCache(defaultConfig)
+
+        expect(mockCaches.open).toHaveBeenCalledWith('test-etag-cache')
+      })
+    })
+
+    describe('get()', () => {
+      it('should return null for cache miss', async () => {
+        mockCache.match.mockResolvedValue(undefined)
+
+        const cache = await createETagCache(defaultConfig)
+        const result = await cache.get('SELECT * FROM users')
+
+        expect(result).toBeNull()
+      })
+
+      it('should return cached result for cache hit', async () => {
+        const cachedResult: CachedQueryResult = {
+          rows: [{ id: 1, name: 'test' }],
+          fields: [{ name: 'id', dataTypeID: 23 }, { name: 'name', dataTypeID: 25 }],
+          rowCount: 1,
+          etag: '"abc123"',
+          cachedAt: Date.now(),
+          affectedTables: ['users'],
+        }
+
+        mockCache.match.mockResolvedValue(
+          new Response(JSON.stringify(cachedResult), {
+            headers: {
+              'Content-Type': 'application/json',
+              'X-Table-Version': '0',
+            },
+          })
+        )
+
+        const cache = await createETagCache(defaultConfig)
+        const result = await cache.get('SELECT * FROM users')
+
+        expect(result).not.toBeNull()
+        expect(result?.rows).toEqual([{ id: 1, name: 'test' }])
+        expect(result?.etag).toBe('"abc123"')
+      })
+
+      it('should invalidate cache when table version is newer', async () => {
+        const cachedResult: CachedQueryResult = {
+          rows: [{ id: 1 }],
+          fields: [{ name: 'id', dataTypeID: 23 }],
+          rowCount: 1,
+          etag: '"abc123"',
+          cachedAt: Date.now(),
+          affectedTables: ['users'],
+        }
+
+        mockCache.match.mockResolvedValue(
+          new Response(JSON.stringify(cachedResult), {
+            headers: {
+              'Content-Type': 'application/json',
+              'X-Table-Version': '1000',
+            },
+          })
+        )
+        mockCache.delete.mockResolvedValue(true)
+
+        const cache = await createETagCache(defaultConfig)
+        // First invalidate the table
+        cache.invalidateTables(['users'])
+        // Then try to get cached result
+        const result = await cache.get('SELECT * FROM users')
+
+        expect(result).toBeNull()
+      })
+
+      it('should track hit statistics', async () => {
+        const cachedResult: CachedQueryResult = {
+          rows: [{ id: 1 }],
+          fields: [],
+          rowCount: 1,
+          etag: '"abc123"',
+          cachedAt: Date.now(),
+          affectedTables: ['users'],
+        }
+
+        mockCache.match.mockResolvedValue(
+          new Response(JSON.stringify(cachedResult), {
+            headers: { 'X-Table-Version': '0' },
+          })
+        )
+
+        const cache = await createETagCache(defaultConfig)
+        await cache.get('SELECT * FROM users')
+
+        const stats = cache.getStats()
+        expect(stats.hits).toBe(1)
+        expect(stats.misses).toBe(0)
+      })
+
+      it('should track miss statistics', async () => {
+        mockCache.match.mockResolvedValue(undefined)
+
+        const cache = await createETagCache(defaultConfig)
+        await cache.get('SELECT * FROM users')
+
+        const stats = cache.getStats()
+        expect(stats.hits).toBe(0)
+        expect(stats.misses).toBe(1)
+      })
+    })
+
+    describe('getConditional()', () => {
+      it('should return notModified=true when ETag matches', async () => {
+        const cachedResult: CachedQueryResult = {
+          rows: [{ id: 1 }],
+          fields: [],
+          rowCount: 1,
+          etag: '"abc123"',
+          cachedAt: Date.now(),
+          affectedTables: ['users'],
+        }
+
+        mockCache.match.mockResolvedValue(
+          new Response(JSON.stringify(cachedResult), {
+            headers: { 'X-Table-Version': '0' },
+          })
+        )
+
+        const cache = await createETagCache(defaultConfig)
+        const result = await cache.getConditional('SELECT * FROM users', undefined, '"abc123"')
+
+        expect(result.notModified).toBe(true)
+        expect(result.etag).toBe('"abc123"')
+        expect(result.result).toBeUndefined()
+      })
+
+      it('should return notModified=false when ETag does not match', async () => {
+        const cachedResult: CachedQueryResult = {
+          rows: [{ id: 1 }],
+          fields: [],
+          rowCount: 1,
+          etag: '"abc123"',
+          cachedAt: Date.now(),
+          affectedTables: ['users'],
+        }
+
+        mockCache.match.mockResolvedValue(
+          new Response(JSON.stringify(cachedResult), {
+            headers: { 'X-Table-Version': '0' },
+          })
+        )
+
+        const cache = await createETagCache(defaultConfig)
+        const result = await cache.getConditional('SELECT * FROM users', undefined, '"different"')
+
+        expect(result.notModified).toBe(false)
+        expect(result.result).toBeDefined()
+      })
+
+      it('should return notModified=false when no cached data', async () => {
+        mockCache.match.mockResolvedValue(undefined)
+
+        const cache = await createETagCache(defaultConfig)
+        const result = await cache.getConditional('SELECT * FROM users', undefined, '"abc123"')
+
+        expect(result.notModified).toBe(false)
+        expect(result.etag).toBe('')
+      })
+
+      it('should track notModified statistics', async () => {
+        const cachedResult: CachedQueryResult = {
+          rows: [{ id: 1 }],
+          fields: [],
+          rowCount: 1,
+          etag: '"abc123"',
+          cachedAt: Date.now(),
+          affectedTables: ['users'],
+        }
+
+        mockCache.match.mockResolvedValue(
+          new Response(JSON.stringify(cachedResult), {
+            headers: { 'X-Table-Version': '0' },
+          })
+        )
+
+        const cache = await createETagCache(defaultConfig)
+        await cache.getConditional('SELECT * FROM users', undefined, '"abc123"')
+
+        const stats = cache.getStats()
+        expect(stats.notModified).toBe(1)
+      })
+    })
+
+    describe('put()', () => {
+      it('should store query result in cache', async () => {
+        const cache = await createETagCache(defaultConfig)
+        const rows = [{ id: 1, name: 'test' }]
+        const fields = [{ name: 'id', dataTypeID: 23 }]
+
+        const result = await cache.put('SELECT * FROM users', undefined, rows, fields)
+
+        expect(mockCache.put).toHaveBeenCalled()
+        expect(result.rows).toEqual(rows)
+        expect(result.etag).toMatch(/^"[a-f0-9]{16}"$/)
+      })
+
+      it('should generate weak ETags when configured', async () => {
+        const cache = await createETagCache({ ...defaultConfig, useWeakETags: true })
+        const rows = [{ id: 1 }]
+        const fields = [{ name: 'id', dataTypeID: 23 }]
+
+        const result = await cache.put('SELECT * FROM users', undefined, rows, fields)
+
+        expect(result.etag).toMatch(/^W\/"[a-f0-9]{16}"$/)
+      })
+
+      it('should set Cache-Control header with TTL', async () => {
+        const cache = await createETagCache({ ...defaultConfig, ttlSeconds: 7200 })
+        const rows = [{ id: 1 }]
+        const fields = [{ name: 'id', dataTypeID: 23 }]
+
+        await cache.put('SELECT * FROM users', undefined, rows, fields)
+
+        const response = mockCache.put.mock.calls[0][1] as Response
+        expect(response.headers.get('Cache-Control')).toContain('max-age=7200')
+      })
+
+      it('should include affected tables in response headers', async () => {
+        const cache = await createETagCache(defaultConfig)
+        const rows = [{ id: 1 }]
+        const fields = [{ name: 'id', dataTypeID: 23 }]
+
+        await cache.put('SELECT * FROM users', undefined, rows, fields)
+
+        const response = mockCache.put.mock.calls[0][1] as Response
+        expect(response.headers.get('X-Affected-Tables')).toBe('users')
+      })
+
+      it('should handle query parameters in cache key', async () => {
+        const cache = await createETagCache(defaultConfig)
+        const rows = [{ id: 1 }]
+        const fields = [{ name: 'id', dataTypeID: 23 }]
+
+        await cache.put('SELECT * FROM users WHERE id = $1', [1], rows, fields)
+        await cache.put('SELECT * FROM users WHERE id = $1', [2], rows, fields)
+
+        // Should have been called twice with different keys
+        expect(mockCache.put).toHaveBeenCalledTimes(2)
+        const key1 = (mockCache.put.mock.calls[0][0] as Request).url
+        const key2 = (mockCache.put.mock.calls[1][0] as Request).url
+        expect(key1).not.toBe(key2)
+      })
+    })
+
+    describe('invalidateTables()', () => {
+      it('should increment table versions', async () => {
+        const cache = await createETagCache(defaultConfig)
+
+        cache.invalidateTables(['users', 'orders'])
+
+        const stats = cache.getStats()
+        expect(stats.invalidations).toBe(2)
+        expect(stats.trackedTables).toBe(2)
+      })
+
+      it('should cause cache misses for affected queries', async () => {
+        const cachedResult: CachedQueryResult = {
+          rows: [{ id: 1 }],
+          fields: [],
+          rowCount: 1,
+          etag: '"abc123"',
+          cachedAt: Date.now(),
+          affectedTables: ['users'],
+        }
+
+        mockCache.match.mockResolvedValue(
+          new Response(JSON.stringify(cachedResult), {
+            headers: { 'X-Table-Version': '1000' },
+          })
+        )
+        mockCache.delete.mockResolvedValue(true)
+
+        const cache = await createETagCache(defaultConfig)
+        // Invalidate after the cached version
+        cache.invalidateTables(['users'])
+
+        const result = await cache.get('SELECT * FROM users')
+        expect(result).toBeNull()
+      })
+    })
+
+    describe('handleWriteQuery()', () => {
+      it('should invalidate tables for INSERT', async () => {
+        const cache = await createETagCache(defaultConfig)
+
+        cache.handleWriteQuery('INSERT INTO users (name) VALUES ($1)')
+
+        const stats = cache.getStats()
+        expect(stats.invalidations).toBe(1)
+      })
+
+      it('should invalidate tables for UPDATE', async () => {
+        const cache = await createETagCache(defaultConfig)
+
+        cache.handleWriteQuery('UPDATE users SET name = $1 WHERE id = $2')
+
+        const stats = cache.getStats()
+        expect(stats.invalidations).toBe(1)
+      })
+
+      it('should invalidate tables for DELETE', async () => {
+        const cache = await createETagCache(defaultConfig)
+
+        cache.handleWriteQuery('DELETE FROM users WHERE id = $1')
+
+        const stats = cache.getStats()
+        expect(stats.invalidations).toBe(1)
+      })
+
+      it('should not invalidate tables for SELECT', async () => {
+        const cache = await createETagCache(defaultConfig)
+
+        cache.handleWriteQuery('SELECT * FROM users')
+
+        const stats = cache.getStats()
+        expect(stats.invalidations).toBe(0)
+      })
+    })
+
+    describe('delete()', () => {
+      it('should delete specific cache entry', async () => {
+        mockCache.delete.mockResolvedValue(true)
+
+        const cache = await createETagCache(defaultConfig)
+        const result = await cache.delete('SELECT * FROM users')
+
+        expect(result).toBe(true)
+        expect(mockCache.delete).toHaveBeenCalled()
+      })
+
+      it('should return false if entry did not exist', async () => {
+        mockCache.delete.mockResolvedValue(false)
+
+        const cache = await createETagCache(defaultConfig)
+        const result = await cache.delete('SELECT * FROM nonexistent')
+
+        expect(result).toBe(false)
+      })
+    })
+
+    describe('getStats()', () => {
+      it('should return ETagCacheStats object', async () => {
+        const cache = await createETagCache(defaultConfig)
+
+        const stats = cache.getStats()
+
+        expect(stats).toHaveProperty('hits')
+        expect(stats).toHaveProperty('misses')
+        expect(stats).toHaveProperty('notModified')
+        expect(stats).toHaveProperty('invalidations')
+        expect(stats).toHaveProperty('trackedTables')
+      })
+    })
+
+    describe('resetStats()', () => {
+      it('should reset all statistics to zero', async () => {
+        mockCache.match.mockResolvedValue(undefined)
+
+        const cache = await createETagCache(defaultConfig)
+        await cache.get('SELECT * FROM users')
+        await cache.get('SELECT * FROM orders')
+
+        cache.resetStats()
+
+        const stats = cache.getStats()
+        expect(stats.hits).toBe(0)
+        expect(stats.misses).toBe(0)
+        expect(stats.notModified).toBe(0)
+        expect(stats.invalidations).toBe(0)
+      })
+    })
+
+    describe('clearTableVersions()', () => {
+      it('should clear all tracked table versions', async () => {
+        const cache = await createETagCache(defaultConfig)
+        cache.invalidateTables(['users', 'orders'])
+
+        cache.clearTableVersions()
+
+        const stats = cache.getStats()
+        expect(stats.trackedTables).toBe(0)
+      })
+    })
+
+    describe('getConfig()', () => {
+      it('should return a copy of the configuration', async () => {
+        const cache = await createETagCache(defaultConfig)
+
+        const config = cache.getConfig()
+
+        expect(config).toEqual(defaultConfig)
+        expect(config).not.toBe(defaultConfig) // Should be a copy
+      })
+    })
+  })
+
+  describe('createETagHeaders()', () => {
+    it('should create headers with ETag', () => {
+      const headers = createETagHeaders('"abc123"')
+
+      expect(headers.get('ETag')).toBe('"abc123"')
+    })
+
+    it('should include Cache-Control when provided', () => {
+      const headers = createETagHeaders('"abc123"', 'public, max-age=3600')
+
+      expect(headers.get('ETag')).toBe('"abc123"')
+      expect(headers.get('Cache-Control')).toBe('public, max-age=3600')
+    })
+
+    it('should not include Cache-Control when not provided', () => {
+      const headers = createETagHeaders('"abc123"')
+
+      expect(headers.get('ETag')).toBe('"abc123"')
+      expect(headers.get('Cache-Control')).toBeNull()
+    })
+  })
+
+  describe('createNotModifiedResponse()', () => {
+    it('should create a 304 response', () => {
+      const response = createNotModifiedResponse('"abc123"')
+
+      expect(response.status).toBe(304)
+      expect(response.statusText).toBe('Not Modified')
+    })
+
+    it('should include ETag header', () => {
+      const response = createNotModifiedResponse('"abc123"')
+
+      expect(response.headers.get('ETag')).toBe('"abc123"')
+    })
+
+    it('should have no body', async () => {
+      const response = createNotModifiedResponse('"abc123"')
+      const body = await response.text()
+
+      expect(body).toBe('')
+    })
+  })
+
+  describe('Error handling', () => {
+    const errorTestConfig: ETagCacheConfig = {
+      cacheName: 'error-test-cache',
+      ttlSeconds: 3600,
+      baseUrl: 'https://error.cache.local',
+      useWeakETags: false,
+    }
+
+    it('should handle cache match errors gracefully', async () => {
+      mockCache.match.mockRejectedValue(new Error('Cache unavailable'))
+
+      const cache = await createETagCache(errorTestConfig)
+      const result = await cache.get('SELECT * FROM users')
+
+      expect(result).toBeNull()
+    })
+
+    it('should handle cache put errors gracefully', async () => {
+      mockCache.put.mockRejectedValue(new Error('Cache unavailable'))
+
+      const cache = await createETagCache(errorTestConfig)
+      const rows = [{ id: 1 }]
+      const fields = [{ name: 'id', dataTypeID: 23 }]
+
+      // Should not throw
+      const result = await cache.put('SELECT * FROM users', undefined, rows, fields)
+      expect(result).toBeDefined()
+    })
+
+    it('should handle cache delete errors gracefully', async () => {
+      mockCache.delete.mockRejectedValue(new Error('Cache unavailable'))
+
+      const cache = await createETagCache(errorTestConfig)
+      const result = await cache.delete('SELECT * FROM users')
+
+      expect(result).toBe(false)
+    })
+  })
+})