@dotdo/postgres 0.1.0

package/src/routing/do-connection-pool.test.ts

@@ -0,0 +1,1109 @@
+/**
+ * Tests for DO Connection Pool
+ *
+ * Task: postgres-zjj
+ *
+ * Tests cover:
+ * - Basic pool operations (acquire, release, destroy)
+ * - Connection reuse
+ * - Max pool size enforcement
+ * - Idle connection timeout
+ * - Health checking
+ * - Fair queuing when pool exhausted
+ * - High-concurrency scenarios
+ * - Pool metrics
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import {
+  DOConnectionPool,
+  DOPoolConfig,
+  DOPoolMetrics,
+  PoolableConnection,
+  ConnectionFactory,
+  HealthChecker,
+} from './do-connection-pool'
+
+// Mock connection implementation
+class MockConnection implements PoolableConnection {
+  readonly id: string
+  private lastActivity: number
+  private _healthy = true
+  private _closed = false
+  public closeDelay = 0
+
+  constructor(id: string) {
+    this.id = id
+    this.lastActivity = Date.now()
+  }
+
+  isHealthy(): boolean {
+    return this._healthy && !this._closed
+  }
+
+  async close(): Promise<void> {
+    if (this.closeDelay > 0) {
+      await new Promise(resolve => setTimeout(resolve, this.closeDelay))
+    }
+    this._closed = true
+  }
+
+  getLastActivity(): number {
+    return this.lastActivity
+  }
+
+  touch(): void {
+    this.lastActivity = Date.now()
+  }
+
+  markUnhealthy(): void {
+    this._healthy = false
+  }
+
+  markHealthy(): void {
+    this._healthy = true
+  }
+
+  get isClosed(): boolean {
+    return this._closed
+  }
+}
+
+// Factory helper
+let connectionIdCounter = 0
+
+function createMockFactory(delay = 0): ConnectionFactory<MockConnection> {
+  return async () => {
+    if (delay > 0) {
+      await new Promise(resolve => setTimeout(resolve, delay))
+    }
+    return new MockConnection(`mock-${++connectionIdCounter}`)
+  }
+}
+
+function createFailingFactory(failCount: number): ConnectionFactory<MockConnection> {
+  let failures = 0
+  return async () => {
+    if (failures < failCount) {
+      failures++
+      throw new Error('Connection failed')
+    }
+    return new MockConnection(`mock-${++connectionIdCounter}`)
+  }
+}
+
+describe('DOConnectionPool', () => {
+  beforeEach(() => {
+    connectionIdCounter = 0
+    vi.useFakeTimers()
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  describe('basic operations', () => {
+    it('should acquire a connection when pool is empty', async () => {
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 5,
+      })
+
+      const conn = await pool.acquire()
+
+      expect(conn).toBeDefined()
+      expect(conn.id).toBe('mock-1')
+      expect(pool.size).toBe(1)
+
+      await pool.close()
+    })
+
+    it('should release connection back to pool', async () => {
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 5,
+      })
+
+      const conn = await pool.acquire()
+      await pool.release(conn)
+
+      expect(pool.size).toBe(1)
+      expect(pool.availableCount).toBe(1)
+
+      await pool.close()
+    })
+
+    it('should destroy connection without returning to pool', async () => {
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 5,
+      })
+
+      const conn = await pool.acquire()
+      await pool.destroy(conn)
+
+      expect(pool.size).toBe(0)
+      expect(pool.availableCount).toBe(0)
+      expect(conn.isClosed).toBe(true)
+
+      await pool.close()
+    })
+
+    it('should throw when acquiring from closed pool', async () => {
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 5,
+      })
+
+      await pool.close()
+
+      await expect(pool.acquire()).rejects.toThrow('Pool is closed')
+    })
+  })
+
+  describe('connection reuse', () => {
+    it('should reuse released connections', async () => {
+      vi.useRealTimers()
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 5,
+        enableHealthCheck: false,
+      })
+
+      const conn1 = await pool.acquire()
+      const conn1Id = conn1.id
+      await pool.release(conn1)
+
+      const conn2 = await pool.acquire()
+
+      expect(conn2.id).toBe(conn1Id)
+      expect(pool.size).toBe(1)
+
+      await pool.close()
+    })
+
+    it('should create new connection when no idle available', async () => {
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 5,
+      })
+
+      const conn1 = await pool.acquire()
+      const conn2 = await pool.acquire()
+
+      expect(conn1.id).not.toBe(conn2.id)
+      expect(pool.size).toBe(2)
+
+      await pool.close()
+    })
+
+    it('should track connection use count', async () => {
+      vi.useRealTimers()
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 5,
+        enableHealthCheck: false,
+      })
+
+      const conn1 = await pool.acquire()
+      await pool.release(conn1)
+
+      const conn2 = await pool.acquire()
+      await pool.release(conn2)
+
+      const stats = pool.getConnectionStats()
+      expect(stats[0].useCount).toBe(2)
+
+      await pool.close()
+    })
+  })
+
+  describe('max pool size', () => {
+    it('should respect max pool size', async () => {
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 2,
+        fairQueue: false,
+      })
+
+      const conn1 = await pool.acquire()
+      const conn2 = await pool.acquire()
+
+      await expect(pool.acquire()).rejects.toThrow('Pool exhausted')
+
+      await pool.close()
+    })
+
+    it('should queue requests when pool exhausted with fairQueue enabled', async () => {
+      vi.useRealTimers()
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 1,
+        fairQueue: true,
+        acquireTimeoutMs: 5000,
+      })
+
+      const conn1 = await pool.acquire()
+
+      // Start acquiring second connection (should queue)
+      const conn2Promise = pool.acquire()
+
+      // Release first connection after delay
+      setTimeout(async () => {
+        await pool.release(conn1)
+      }, 50)
+
+      const conn2 = await conn2Promise
+
+      expect(conn2.id).toBe(conn1.id)
+
+      await pool.close()
+    })
+
+    it('should timeout when queue wait exceeds timeout', async () => {
+      vi.useRealTimers()
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 1,
+        fairQueue: true,
+        acquireTimeoutMs: 50,
+      })
+
+      await pool.acquire()
+
+      await expect(pool.acquire()).rejects.toThrow('Acquire timeout')
+
+      await pool.close()
+    })
+
+    it('should enforce max queue size', async () => {
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 1,
+        fairQueue: true,
+        maxQueueSize: 1,
+        acquireTimeoutMs: 5000,
+      })
+
+      await pool.acquire()
+      pool.acquire().catch(() => {}) // First queued request
+
+      await expect(pool.acquire()).rejects.toThrow('max queue size reached')
+
+      await pool.close()
+    })
+  })
+
+  describe('idle connection timeout', () => {
+    it('should close idle connections after timeout', async () => {
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 5,
+        idleTimeoutMs: 100,
+        minSize: 0,
+        enableHealthCheck: false, // Disable to avoid infinite interval loops
+      })
+
+      const conn = await pool.acquire()
+      await pool.release(conn)
+
+      expect(pool.size).toBe(1)
+
+      // Fast-forward past idle timeout using async version for single advance
+      await vi.advanceTimersByTimeAsync(150)
+
+      expect(pool.size).toBe(0)
+
+      await pool.close()
+    })
+
+    it('should not close connections below minSize', async () => {
+      vi.useRealTimers()
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 5,
+        minSize: 1,
+        idleTimeoutMs: 50,
+        enableHealthCheck: false, // Disable to avoid interval loops
+      })
+
+      const conn = await pool.acquire()
+      await pool.release(conn)
+
+      // Wait for idle timeout to pass
+      await new Promise(resolve => setTimeout(resolve, 100))
+
+      // Connection should still exist due to minSize
+      expect(pool.size).toBe(1)
+
+      await pool.close()
+    })
+  })
+
+  describe('health checking', () => {
+    it('should reject unhealthy connections on acquire', async () => {
+      vi.useRealTimers()
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 5,
+        enableHealthCheck: true,
+      })
+
+      const conn1 = await pool.acquire()
+      conn1.markUnhealthy()
+      await pool.release(conn1)
+
+      // Next acquire should get a new connection (old one is unhealthy)
+      const conn2 = await pool.acquire()
+      expect(conn2.id).not.toBe(conn1.id)
+
+      await pool.close()
+    })
+
+    it('should run periodic health checks', async () => {
+      vi.useRealTimers()
+
+      const healthChecker = vi.fn().mockResolvedValue(true)
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 5,
+        enableHealthCheck: true,
+        healthCheckIntervalMs: 50,
+        healthChecker,
+      })
+
+      const conn = await pool.acquire()
+      await pool.release(conn)
+
+      // Wait for health check interval to fire
+      await new Promise(resolve => setTimeout(resolve, 100))
+
+      expect(healthChecker).toHaveBeenCalled()
+
+      await pool.close()
+    })
+
+    it('should remove connections that fail health check', async () => {
+      vi.useRealTimers()
+
+      let healthCheckCount = 0
+      const healthChecker: HealthChecker<MockConnection> = async () => {
+        healthCheckCount++
+        return healthCheckCount === 1 // Pass first, fail second
+      }
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 5,
+        enableHealthCheck: true,
+        healthCheckIntervalMs: 50,
+        healthChecker,
+        minSize: 0,
+      })
+
+      const conn = await pool.acquire()
+      await pool.release(conn)
+
+      expect(pool.size).toBe(1)
+
+      // Wait for first health check (should pass)
+      await new Promise(resolve => setTimeout(resolve, 75))
+
+      expect(pool.size).toBe(1)
+
+      // Wait for second health check (should fail)
+      await new Promise(resolve => setTimeout(resolve, 75))
+
+      expect(pool.size).toBe(0)
+
+      await pool.close()
+    })
+
+    it('should use custom health checker', async () => {
+      vi.useRealTimers()
+
+      const customChecker = vi.fn().mockResolvedValue(true)
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 5,
+        enableHealthCheck: true,
+        healthChecker: customChecker,
+        healthCheckIntervalMs: 50,
+      })
+
+      const conn = await pool.acquire()
+      await pool.release(conn)
+
+      // Wait for health check interval to fire
+      await new Promise(resolve => setTimeout(resolve, 100))
+
+      expect(customChecker).toHaveBeenCalledWith(conn)
+
+      await pool.close()
+    })
+  })
+
+  describe('fair queuing', () => {
+    it('should process queued requests in FIFO order', async () => {
+      vi.useRealTimers()
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 1,
+        fairQueue: true,
+        acquireTimeoutMs: 5000,
+        enableHealthCheck: false, // Disable to avoid interval issues
+      })
+
+      const conn1 = await pool.acquire()
+
+      const order: number[] = []
+      const connections: MockConnection[] = []
+
+      // Queue multiple requests - store connections so we can release them
+      const p1 = pool.acquire().then(c => { order.push(1); connections.push(c); return c })
+      const p2 = pool.acquire().then(c => { order.push(2); connections.push(c); return c })
+      const p3 = pool.acquire().then(c => { order.push(3); connections.push(c); return c })
+
+      // Give time for requests to queue
+      await new Promise(resolve => setTimeout(resolve, 10))
+
+      // Release initial connection - this triggers p1
+      await pool.release(conn1)
+      await p1
+
+      // Release for p2
+      if (connections.length > 0) {
+        await pool.release(connections[0])
+        await p2
+      }
+
+      // Release for p3
+      if (connections.length > 1) {
+        await pool.release(connections[1])
+        await p3
+      }
+
+      // Requests should be processed in FIFO order
+      expect(order).toEqual([1, 2, 3])
+
+      await pool.close()
+    })
+
+    it('should handle release to waiting request directly', async () => {
+      vi.useRealTimers()
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 1,
+        fairQueue: true,
+        acquireTimeoutMs: 5000,
+        enableHealthCheck: false, // Disable to avoid background interval issues
+      })
+
+      const conn1 = await pool.acquire()
+
+      // Start waiting for second connection (don't await yet)
+      const conn2Promise = pool.acquire()
+
+      // Give microtask queue time to process
+      await new Promise(resolve => setTimeout(resolve, 10))
+
+      // Release should go directly to waiting request
+      await pool.release(conn1)
+
+      const conn2 = await conn2Promise
+
+      expect(conn2.id).toBe(conn1.id)
+      expect(pool.queueLength).toBe(0)
+
+      await pool.close()
+    })
+  })
+
+  describe('high concurrency', () => {
+    it('should handle many concurrent acquire requests', async () => {
+      vi.useRealTimers()
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(5), // 5ms delay for each connection
+        maxSize: 10,
+        fairQueue: true,
+        acquireTimeoutMs: 10000,
+      })
+
+      // Acquire 10 connections concurrently
+      const promises = Array(10).fill(null).map(() => pool.acquire())
+      const connections = await Promise.all(promises)
+
+      expect(connections).toHaveLength(10)
+      expect(pool.size).toBe(10)
+
+      // All connections should be unique
+      const ids = new Set(connections.map(c => c.id))
+      expect(ids.size).toBe(10)
+
+      await pool.close()
+    })
+
+    it('should handle concurrent acquire and release', async () => {
+      vi.useRealTimers()
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 5,
+        fairQueue: true,
+        acquireTimeoutMs: 5000,
+        enableHealthCheck: false,
+      })
+
+      // Simulate high-concurrency scenario
+      const operations: Promise<void>[] = []
+
+      for (let i = 0; i < 50; i++) {
+        operations.push((async () => {
+          const conn = await pool.acquire()
+          // Simulate some work
+          await new Promise(resolve => setTimeout(resolve, Math.random() * 10))
+          await pool.release(conn)
+        })())
+      }
+
+      await Promise.all(operations)
+
+      const metrics = pool.getMetrics()
+      expect(metrics.totalAcquisitions).toBe(50)
+      expect(metrics.totalReleases).toBe(50)
+
+      await pool.close()
+    })
+
+    it('should handle acquire timeout under load', async () => {
+      vi.useRealTimers()
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(100), // Slow connection creation
+        maxSize: 2,
+        fairQueue: true,
+        acquireTimeoutMs: 50,
+      })
+
+      // Fill the pool
+      const conn1 = await pool.acquire()
+      const conn2 = await pool.acquire()
+
+      // Next acquire should timeout
+      const startTime = Date.now()
+      await expect(pool.acquire()).rejects.toThrow('timeout')
+      const elapsed = Date.now() - startTime
+
+      expect(elapsed).toBeGreaterThanOrEqual(40) // Allow some tolerance
+      expect(elapsed).toBeLessThan(150)
+
+      await pool.close()
+    })
+
+    it('should track timeout metrics', async () => {
+      vi.useRealTimers()
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 1,
+        fairQueue: true,
+        acquireTimeoutMs: 20,
+      })
+
+      await pool.acquire()
+
+      // Try to acquire more (should timeout)
+      const promises = [
+        pool.acquire().catch(() => {}),
+        pool.acquire().catch(() => {}),
+      ]
+
+      await Promise.all(promises)
+
+      const metrics = pool.getMetrics()
+      expect(metrics.totalTimeouts).toBe(2)
+
+      await pool.close()
+    })
+  })
+
+  describe('pool metrics', () => {
+    it('should track basic metrics', async () => {
+      vi.useRealTimers()
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 5,
+        enableHealthCheck: false,
+      })
+
+      const conn1 = await pool.acquire()
+      const conn2 = await pool.acquire()
+      await pool.release(conn1)
+
+      const metrics = pool.getMetrics()
+
+      expect(metrics.totalCreated).toBe(2)
+      expect(metrics.currentSize).toBe(2)
+      expect(metrics.inUse).toBe(1)
+      expect(metrics.available).toBe(1)
+      expect(metrics.totalAcquisitions).toBe(2)
+      expect(metrics.totalReleases).toBe(1)
+
+      await pool.close()
+    })
+
+    it('should calculate utilization percentage', async () => {
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 5,
+      })
+
+      const conn1 = await pool.acquire()
+      const conn2 = await pool.acquire()
+
+      let metrics = pool.getMetrics()
+      expect(metrics.utilizationPercent).toBe(100) // 2/2 = 100%
+
+      await pool.release(conn1)
+
+      metrics = pool.getMetrics()
+      expect(metrics.utilizationPercent).toBe(50) // 1/2 = 50%
+
+      await pool.close()
+    })
+
+    it('should track wait times', async () => {
+      vi.useRealTimers()
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(50), // 50ms delay
+        maxSize: 5,
+      })
+
+      await pool.acquire()
+      await pool.acquire()
+
+      const metrics = pool.getMetrics()
+      expect(metrics.avgWaitTimeMs).toBeGreaterThan(0)
+
+      await pool.close()
+    })
+
+    it('should track health check metrics', async () => {
+      vi.useRealTimers()
+
+      const healthChecker = vi.fn()
+        .mockResolvedValueOnce(true)
+        .mockResolvedValueOnce(false)
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 5,
+        enableHealthCheck: true,
+        healthCheckIntervalMs: 30,
+        healthChecker,
+        minSize: 0,
+      })
+
+      const conn = await pool.acquire()
+      await pool.release(conn)
+
+      // Wait for health checks to run
+      await new Promise(resolve => setTimeout(resolve, 50))
+      await new Promise(resolve => setTimeout(resolve, 50))
+
+      const metrics = pool.getMetrics()
+      expect(metrics.totalHealthChecks).toBeGreaterThanOrEqual(1)
+      expect(metrics.totalHealthCheckFailures).toBeGreaterThanOrEqual(1)
+
+      await pool.close()
+    })
+
+    it('should track queue length', async () => {
+      vi.useRealTimers()
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 1,
+        fairQueue: true,
+        acquireTimeoutMs: 5000,
+      })
+
+      await pool.acquire()
+
+      // Queue some requests
+      pool.acquire().catch(() => {})
+      pool.acquire().catch(() => {})
+
+      // Allow microtask queue to process
+      await new Promise(resolve => setTimeout(resolve, 0))
+
+      const metrics = pool.getMetrics()
+      expect(metrics.queueLength).toBe(2)
+      expect(metrics.pendingRequests).toBe(2)
+
+      await pool.close()
+    })
+  })
+
+  describe('connection stats', () => {
+    it('should provide per-connection statistics', async () => {
+      vi.useRealTimers()
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 5,
+        enableHealthCheck: false,
+      })
+
+      const conn = await pool.acquire()
+      await pool.release(conn)
+      await pool.acquire()
+
+      const stats = pool.getConnectionStats()
+
+      expect(stats).toHaveLength(1)
+      expect(stats[0].id).toBe(conn.id)
+      expect(stats[0].useCount).toBe(2)
+      expect(stats[0].createdAt).toBeDefined()
+      expect(stats[0].lastUsedAt).toBeDefined()
+
+      await pool.close()
+    })
+  })
+
+  describe('minimum pool size', () => {
+    it('should maintain minimum connections after destroy', async () => {
+      vi.useRealTimers()
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 5,
+        minSize: 2,
+        warmOnStart: true,
+        warmCount: 2,
+        enableHealthCheck: false, // Disable to avoid interval issues
+      })
+
+      // Initialize with min size
+      await pool.initialize()
+
+      expect(pool.size).toBeGreaterThanOrEqual(2)
+
+      // Destroy a connection
+      const conn = await pool.acquire()
+      await pool.destroy(conn)
+
+      // Should create new connection to maintain min size (ensureMinSize is called in destroy)
+      // Give async operations time to complete
+      await new Promise(resolve => setTimeout(resolve, 50))
+
+      expect(pool.size).toBeGreaterThanOrEqual(1)
+
+      await pool.close()
+    })
+  })
+
+  describe('warm start', () => {
+    it('should warm connections on initialize', async () => {
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 10,
+        warmOnStart: true,
+        warmCount: 3,
+      })
+
+      await pool.initialize()
+
+      expect(pool.size).toBe(3)
+      expect(pool.availableCount).toBe(3)
+
+      await pool.close()
+    })
+
+    it('should respect maxSize during warm start', async () => {
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 2,
+        warmOnStart: true,
+        warmCount: 5,
+      })
+
+      await pool.initialize()
+
+      expect(pool.size).toBe(2)
+
+      await pool.close()
+    })
+
+    it('should handle warm start failures gracefully', async () => {
+      const pool = new DOConnectionPool({
+        factory: createFailingFactory(2),
+        maxSize: 5,
+        warmOnStart: true,
+        warmCount: 3,
+      })
+
+      // Should not throw
+      await pool.initialize()
+
+      // Only 1 connection should have succeeded
+      expect(pool.size).toBe(1)
+
+      await pool.close()
+    })
+  })
+
+  describe('auto scaling', () => {
+    it('should scale up when utilization exceeds threshold', async () => {
+      vi.useRealTimers()
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 10,
+        minSize: 1,
+        autoScale: true,
+        scaleUpThreshold: 0.5,
+        healthCheckIntervalMs: 50,
+        warmOnStart: true,
+        warmCount: 1,
+      })
+
+      // Start with one connection
+      await pool.initialize()
+      const conn = await pool.acquire()
+
+      // Utilization is now 100%, above threshold
+      // Wait for auto-scale check interval to fire
+      await new Promise(resolve => setTimeout(resolve, 100))
+
+      // Should have scaled up
+      expect(pool.size).toBeGreaterThanOrEqual(1)
+
+      await pool.close()
+    })
+  })
+
+  describe('pool closure', () => {
+    it('should reject pending requests on close', async () => {
+      vi.useRealTimers()
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 1,
+        fairQueue: true,
+        acquireTimeoutMs: 5000,
+        enableHealthCheck: false, // Disable to avoid interval issues
+      })
+
+      await pool.acquire()
+
+      const pendingPromise = pool.acquire()
+
+      // Give time for the request to be queued
+      await new Promise(resolve => setTimeout(resolve, 10))
+
+      await pool.close()
+
+      await expect(pendingPromise).rejects.toThrow('Pool closed')
+    })
+
+    it('should close all connections on pool close', async () => {
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 5,
+      })
+
+      const connections = await Promise.all([
+        pool.acquire(),
+        pool.acquire(),
+        pool.acquire(),
+      ])
+
+      await pool.close()
+
+      for (const conn of connections) {
+        expect(conn.isClosed).toBe(true)
+      }
+    })
+
+    it('should release connection to closed pool gracefully', async () => {
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 5,
+      })
+
+      const conn = await pool.acquire()
+      await pool.close()
+
+      // Should not throw
+      await pool.release(conn)
+      expect(conn.isClosed).toBe(true)
+    })
+  })
+
+  describe('error handling', () => {
+    it('should handle factory errors', async () => {
+      const failingFactory = vi.fn().mockRejectedValue(new Error('Factory error'))
+
+      const pool = new DOConnectionPool({
+        factory: failingFactory,
+        maxSize: 5,
+        fairQueue: false,
+      })
+
+      await expect(pool.acquire()).rejects.toThrow('Factory error')
+
+      await pool.close()
+    })
+
+    it('should handle connection close errors gracefully', async () => {
+      vi.useRealTimers()
+
+      const factory: ConnectionFactory<MockConnection> = async () => {
+        const conn = new MockConnection(`mock-${++connectionIdCounter}`)
+        conn.closeDelay = 10
+        const originalClose = conn.close.bind(conn)
+        conn.close = async () => {
+          await originalClose()
+          throw new Error('Close error')
+        }
+        return conn
+      }
+
+      const pool = new DOConnectionPool({
+        factory,
+        maxSize: 5,
+        enableHealthCheck: false, // Disable to avoid interval issues
+      })
+
+      const conn = await pool.acquire()
+
+      // Should not throw
+      await pool.destroy(conn)
+
+      await pool.close()
+    })
+
+    it('should handle validation timeout', async () => {
+      vi.useRealTimers()
+
+      const slowHealthChecker: HealthChecker<MockConnection> = async () => {
+        await new Promise(resolve => setTimeout(resolve, 1000))
+        return true
+      }
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 5,
+        enableHealthCheck: true,
+        healthChecker: slowHealthChecker,
+        validationTimeoutMs: 50,
+      })
+
+      const conn = await pool.acquire()
+      conn.markHealthy()
+      await pool.release(conn)
+
+      // Try to acquire - validation should timeout
+      const conn2 = await pool.acquire()
+
+      // Should get a new connection since validation timed out
+      expect(conn2.id).not.toBe(conn.id)
+
+      await pool.close()
+    })
+  })
+
+  describe('load testing', () => {
+    it('should handle sustained load', async () => {
+      vi.useRealTimers()
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 5,
+        fairQueue: true,
+        acquireTimeoutMs: 5000,
+        enableHealthCheck: false,
+      })
+
+      const iterations = 100
+      let completed = 0
+      const errors: Error[] = []
+
+      const worker = async () => {
+        for (let i = 0; i < iterations / 10; i++) {
+          try {
+            const conn = await pool.acquire()
+            await new Promise(resolve => setTimeout(resolve, Math.random() * 5))
+            await pool.release(conn)
+            completed++
+          } catch (e) {
+            errors.push(e as Error)
+          }
+        }
+      }
+
+      // Run 10 concurrent workers
+      await Promise.all(Array(10).fill(null).map(() => worker()))
+
+      expect(completed).toBe(iterations)
+      expect(errors).toHaveLength(0)
+
+      const metrics = pool.getMetrics()
+      expect(metrics.totalAcquisitions).toBe(iterations)
+      expect(metrics.totalReleases).toBe(iterations)
+
+      await pool.close()
+    })
+
+    it('should maintain fairness under load', async () => {
+      vi.useRealTimers()
+
+      const pool = new DOConnectionPool({
+        factory: createMockFactory(),
+        maxSize: 1,
+        fairQueue: true,
+        acquireTimeoutMs: 10000,
+        enableHealthCheck: false, // Disable to avoid interval issues
+      })
+
+      const conn = await pool.acquire()
+      const acquisitionOrder: number[] = []
+
+      // Queue requests
+      const promises = [1, 2, 3, 4, 5].map(n =>
+        pool.acquire().then(c => {
+          acquisitionOrder.push(n)
+          // Immediately release for next request
+          return pool.release(c)
+        })
+      )
+
+      // Give time for requests to queue
+      await new Promise(resolve => setTimeout(resolve, 10))
+
+      // Release initial connection to start processing queue
+      await pool.release(conn)
+
+      await Promise.all(promises)
+
+      // Requests should be processed in FIFO order
+      expect(acquisitionOrder).toEqual([1, 2, 3, 4, 5])
+
+      await pool.close()
+    })
+  })
+})