@dotdo/postgres 0.1.0

package/src/pglite/r2-layer.test.ts

@@ -0,0 +1,501 @@
+/**
+ * RED PHASE Tests for R2StorageLayer - R2 bucket wrapper with range reads
+ * Task: postgres-xm8.8 - R2StorageLayer - R2 bucket wrapper with range reads
+ *
+ * These tests should FAIL until implementation is complete.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import {
+  R2StorageLayer,
+  R2StorageLayerConfig,
+  R2StorageLayerStats,
+  createR2StorageLayer,
+} from './r2-layer'
+
+// Mock R2Object
+const createMockR2Object = (key: string, size: number = 100) => ({
+  key,
+  size,
+  uploaded: new Date(),
+  httpEtag: `"${key}-etag"`,
+  etag: `${key}-etag`,
+  version: 'v1',
+  httpMetadata: {},
+  customMetadata: {},
+  storageClass: 'Standard',
+  writeHttpMetadata: vi.fn(),
+})
+
+// Mock R2ObjectBody
+const createMockR2ObjectBody = (data: Uint8Array) => ({
+  ...createMockR2Object('test', data.length),
+  body: new ReadableStream({
+    start(controller) {
+      controller.enqueue(data)
+      controller.close()
+    },
+  }),
+  bodyUsed: false,
+  arrayBuffer: vi.fn().mockResolvedValue(data.buffer),
+  bytes: vi.fn().mockResolvedValue(data),
+  text: vi.fn().mockResolvedValue(new TextDecoder().decode(data)),
+  blob: vi.fn().mockResolvedValue(new Blob([data])),
+  json: vi.fn().mockRejectedValue(new Error('Not JSON')),
+})
+
+// Mock R2Bucket
+const mockR2Bucket = {
+  head: vi.fn(),
+  get: vi.fn(),
+  put: vi.fn(),
+  delete: vi.fn(),
+  list: vi.fn(),
+  createMultipartUpload: vi.fn(),
+  resumeMultipartUpload: vi.fn(),
+}
+
+describe('R2StorageLayer - R2 bucket wrapper with range reads', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockR2Bucket.head.mockReset()
+    mockR2Bucket.get.mockReset()
+    mockR2Bucket.put.mockReset()
+    mockR2Bucket.delete.mockReset()
+    mockR2Bucket.list.mockReset()
+  })
+
+  describe('R2StorageLayerConfig', () => {
+    it('should have required config fields', () => {
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      expect(config.bucket).toBeDefined()
+      expect(config.prefix).toBe('pglite/pages/')
+    })
+
+    it('should support optional storageClass', () => {
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+        storageClass: 'InfrequentAccess',
+      }
+      expect(config.storageClass).toBe('InfrequentAccess')
+    })
+  })
+
+  describe('createR2StorageLayer()', () => {
+    it('should return an R2StorageLayer instance', () => {
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      const layer = createR2StorageLayer(config)
+      expect(layer).toBeDefined()
+      expect(layer).toBeInstanceOf(R2StorageLayer)
+    })
+  })
+
+  describe('R2StorageLayer.get()', () => {
+    it('should return null when key does not exist', async () => {
+      mockR2Bucket.get.mockResolvedValue(null)
+
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      const layer = createR2StorageLayer(config)
+
+      const result = await layer.get('nonexistent-page')
+      expect(result).toBeNull()
+    })
+
+    it('should return Uint8Array for existing key', async () => {
+      const data = new Uint8Array([1, 2, 3, 4, 5])
+      mockR2Bucket.get.mockResolvedValue(createMockR2ObjectBody(data))
+
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      const layer = createR2StorageLayer(config)
+
+      const result = await layer.get('page-123')
+      expect(result).toBeInstanceOf(Uint8Array)
+      expect(result).toEqual(data)
+    })
+
+    it('should prepend prefix to key', async () => {
+      mockR2Bucket.get.mockResolvedValue(null)
+
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'my-prefix/',
+      }
+      const layer = createR2StorageLayer(config)
+
+      await layer.get('page-456')
+      expect(mockR2Bucket.get).toHaveBeenCalledWith('my-prefix/page-456')
+    })
+
+    it('should track reads in statistics', async () => {
+      const data = new Uint8Array([1, 2, 3])
+      mockR2Bucket.get.mockResolvedValue(createMockR2ObjectBody(data))
+
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      const layer = createR2StorageLayer(config)
+
+      await layer.get('page-123')
+      const stats = layer.getStats()
+      expect(stats.reads).toBe(1)
+      expect(stats.bytesRead).toBe(3)
+    })
+  })
+
+  describe('R2StorageLayer.getRange()', () => {
+    it('should read a byte range from R2', async () => {
+      const fullData = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+      const rangeData = new Uint8Array([2, 3, 4])
+      mockR2Bucket.get.mockResolvedValue(createMockR2ObjectBody(rangeData))
+
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      const layer = createR2StorageLayer(config)
+
+      const result = await layer.getRange('page-123', 2, 3)
+      expect(result).toEqual(rangeData)
+    })
+
+    it('should pass range options to R2', async () => {
+      const rangeData = new Uint8Array([5, 6, 7])
+      mockR2Bucket.get.mockResolvedValue(createMockR2ObjectBody(rangeData))
+
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      const layer = createR2StorageLayer(config)
+
+      await layer.getRange('page-123', 5, 3)
+      expect(mockR2Bucket.get).toHaveBeenCalledWith(
+        'pglite/pages/page-123',
+        expect.objectContaining({
+          range: { offset: 5, length: 3 },
+        })
+      )
+    })
+
+    it('should return null if key does not exist', async () => {
+      mockR2Bucket.get.mockResolvedValue(null)
+
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      const layer = createR2StorageLayer(config)
+
+      const result = await layer.getRange('nonexistent', 0, 10)
+      expect(result).toBeNull()
+    })
+
+    it('should track range reads in statistics', async () => {
+      const rangeData = new Uint8Array([1, 2, 3, 4, 5])
+      mockR2Bucket.get.mockResolvedValue(createMockR2ObjectBody(rangeData))
+
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      const layer = createR2StorageLayer(config)
+
+      await layer.getRange('page-123', 10, 5)
+      const stats = layer.getStats()
+      expect(stats.rangeReads).toBe(1)
+    })
+  })
+
+  describe('R2StorageLayer.put()', () => {
+    it('should store data in R2', async () => {
+      mockR2Bucket.put.mockResolvedValue(createMockR2Object('test-key', 5))
+
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      const layer = createR2StorageLayer(config)
+
+      const data = new Uint8Array([10, 20, 30, 40, 50])
+      await layer.put('page-789', data)
+
+      expect(mockR2Bucket.put).toHaveBeenCalledWith(
+        'pglite/pages/page-789',
+        data,
+        expect.any(Object)
+      )
+    })
+
+    it('should use configured storage class', async () => {
+      mockR2Bucket.put.mockResolvedValue(createMockR2Object('test-key', 5))
+
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+        storageClass: 'InfrequentAccess',
+      }
+      const layer = createR2StorageLayer(config)
+
+      const data = new Uint8Array([1, 2, 3])
+      await layer.put('page-123', data)
+
+      expect(mockR2Bucket.put).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.any(Uint8Array),
+        expect.objectContaining({
+          storageClass: 'InfrequentAccess',
+        })
+      )
+    })
+
+    it('should track writes in statistics', async () => {
+      mockR2Bucket.put.mockResolvedValue(createMockR2Object('test-key', 4))
+
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      const layer = createR2StorageLayer(config)
+
+      const data = new Uint8Array([1, 2, 3, 4])
+      await layer.put('page-123', data)
+
+      const stats = layer.getStats()
+      expect(stats.writes).toBe(1)
+      expect(stats.bytesWritten).toBe(4)
+    })
+
+    it('should support custom metadata', async () => {
+      mockR2Bucket.put.mockResolvedValue(createMockR2Object('test-key', 3))
+
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      const layer = createR2StorageLayer(config)
+
+      const data = new Uint8Array([1, 2, 3])
+      await layer.put('page-123', data, {
+        customMetadata: { tier: 'cold', lastAccess: '1234567890' },
+      })
+
+      expect(mockR2Bucket.put).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.any(Uint8Array),
+        expect.objectContaining({
+          customMetadata: { tier: 'cold', lastAccess: '1234567890' },
+        })
+      )
+    })
+  })
+
+  describe('R2StorageLayer.delete()', () => {
+    it('should delete a key from R2', async () => {
+      mockR2Bucket.delete.mockResolvedValue(undefined)
+
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      const layer = createR2StorageLayer(config)
+
+      await layer.delete('page-123')
+      expect(mockR2Bucket.delete).toHaveBeenCalledWith('pglite/pages/page-123')
+    })
+
+    it('should track deletes in statistics', async () => {
+      mockR2Bucket.delete.mockResolvedValue(undefined)
+
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      const layer = createR2StorageLayer(config)
+
+      await layer.delete('page-123')
+
+      const stats = layer.getStats()
+      expect(stats.deletes).toBe(1)
+    })
+
+    it('should support batch delete', async () => {
+      mockR2Bucket.delete.mockResolvedValue(undefined)
+
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      const layer = createR2StorageLayer(config)
+
+      await layer.deleteMany(['page-1', 'page-2', 'page-3'])
+      expect(mockR2Bucket.delete).toHaveBeenCalledWith([
+        'pglite/pages/page-1',
+        'pglite/pages/page-2',
+        'pglite/pages/page-3',
+      ])
+    })
+  })
+
+  describe('R2StorageLayer.head()', () => {
+    it('should return object metadata without body', async () => {
+      const mockObj = createMockR2Object('page-123', 1024)
+      mockR2Bucket.head.mockResolvedValue(mockObj)
+
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      const layer = createR2StorageLayer(config)
+
+      const result = await layer.head('page-123')
+      expect(result).not.toBeNull()
+      expect(result?.size).toBe(1024)
+    })
+
+    it('should return null for nonexistent key', async () => {
+      mockR2Bucket.head.mockResolvedValue(null)
+
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      const layer = createR2StorageLayer(config)
+
+      const result = await layer.head('nonexistent')
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('R2StorageLayer.list()', () => {
+    it('should list keys with prefix', async () => {
+      mockR2Bucket.list.mockResolvedValue({
+        objects: [
+          createMockR2Object('pglite/pages/page-1', 100),
+          createMockR2Object('pglite/pages/page-2', 200),
+        ],
+        truncated: false,
+        cursor: undefined,
+      })
+
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      const layer = createR2StorageLayer(config)
+
+      const result = await layer.list()
+      expect(result.keys.length).toBe(2)
+      expect(result.keys[0]).toBe('page-1')
+      expect(result.keys[1]).toBe('page-2')
+    })
+
+    it('should support pagination', async () => {
+      mockR2Bucket.list.mockResolvedValue({
+        objects: [createMockR2Object('pglite/pages/page-1', 100)],
+        truncated: true,
+        cursor: 'next-cursor',
+      })
+
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      const layer = createR2StorageLayer(config)
+
+      const result = await layer.list({ limit: 1 })
+      expect(result.truncated).toBe(true)
+      expect(result.cursor).toBe('next-cursor')
+    })
+  })
+
+  describe('R2StorageLayer.has()', () => {
+    it('should return true if key exists', async () => {
+      mockR2Bucket.head.mockResolvedValue(createMockR2Object('page-123', 100))
+
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      const layer = createR2StorageLayer(config)
+
+      const result = await layer.has('page-123')
+      expect(result).toBe(true)
+    })
+
+    it('should return false if key does not exist', async () => {
+      mockR2Bucket.head.mockResolvedValue(null)
+
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      const layer = createR2StorageLayer(config)
+
+      const result = await layer.has('nonexistent')
+      expect(result).toBe(false)
+    })
+  })
+
+  describe('R2StorageLayer.getStats()', () => {
+    it('should return R2StorageLayerStats object', () => {
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      const layer = createR2StorageLayer(config)
+
+      const stats = layer.getStats()
+      expect(stats).toHaveProperty('reads')
+      expect(stats).toHaveProperty('rangeReads')
+      expect(stats).toHaveProperty('writes')
+      expect(stats).toHaveProperty('deletes')
+      expect(stats).toHaveProperty('bytesRead')
+      expect(stats).toHaveProperty('bytesWritten')
+      expect(stats).toHaveProperty('errors')
+    })
+  })
+
+  describe('Error handling', () => {
+    it('should handle R2 errors gracefully on get', async () => {
+      mockR2Bucket.get.mockRejectedValue(new Error('R2 unavailable'))
+
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      const layer = createR2StorageLayer(config)
+
+      const result = await layer.get('page-123')
+      expect(result).toBeNull()
+    })
+
+    it('should track errors in statistics', async () => {
+      mockR2Bucket.get.mockRejectedValue(new Error('R2 error'))
+
+      const config: R2StorageLayerConfig = {
+        bucket: mockR2Bucket as unknown as R2Bucket,
+        prefix: 'pglite/pages/',
+      }
+      const layer = createR2StorageLayer(config)
+
+      await layer.get('page-123')
+
+      const stats = layer.getStats()
+      expect(stats.errors).toBe(1)
+    })
+  })
+})