@neverinfamous/mysql-mcp 2.1.0 → 2.3.0

package/src/pool/__tests__/ConnectionPool.test.ts

@@ -1,448 +1,482 @@
 /**
  * mysql-mcp - ConnectionPool Unit Tests
- * 
+ *
  * Tests for connection pool initialization, queries, health checks,
  * and lifecycle management using mocked mysql2.
  */
 
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { ConnectionPool } from '../ConnectionPool.js';
-import type { ConnectionPoolConfig } from '../ConnectionPool.js';
-import mysql from 'mysql2/promise';
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { ConnectionPool } from "../ConnectionPool.js";
+import type { ConnectionPoolConfig } from "../ConnectionPool.js";
+import mysql from "mysql2/promise";
 
 // Mock mysql2/promise
-vi.mock('mysql2/promise', () => {
-    const mockConnection = {
-        query: vi.fn().mockResolvedValue([[{ version: '8.0.35' }], []]),
-        execute: vi.fn().mockResolvedValue([[{ id: 1 }], []]),
-        release: vi.fn(),
-        ping: vi.fn().mockResolvedValue(undefined)
-    };
+vi.mock("mysql2/promise", () => {
+  const mockConnection = {
+    query: vi.fn().mockResolvedValue([[{ version: "8.0.35" }], []]),
+    execute: vi.fn().mockResolvedValue([[{ id: 1 }], []]),
+    release: vi.fn(),
+    ping: vi.fn().mockResolvedValue(undefined),
+  };
+
+  const mockPool = {
+    getConnection: vi.fn().mockResolvedValue(mockConnection),
+    query: vi.fn().mockResolvedValue([[], []]),
+    execute: vi.fn().mockResolvedValue([[], []]),
+    end: vi.fn().mockResolvedValue(undefined),
+  };
+
+  return {
+    default: {
+      createPool: vi.fn().mockReturnValue(mockPool),
+    },
+  };
+});
 
-    const mockPool = {
-        getConnection: vi.fn().mockResolvedValue(mockConnection),
-        query: vi.fn().mockResolvedValue([[], []]),
-        execute: vi.fn().mockResolvedValue([[], []]),
-        end: vi.fn().mockResolvedValue(undefined)
+describe("ConnectionPool", () => {
+  let pool: ConnectionPool;
+  let config: ConnectionPoolConfig;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    config = {
+      host: "localhost",
+      port: 3306,
+      user: "root",
+      password: "root",
+      database: "testdb",
     };
+    pool = new ConnectionPool(config);
+  });
 
-    return {
-        default: {
-            createPool: vi.fn().mockReturnValue(mockPool)
-        }
-    };
-});
+  describe("constructor", () => {
+    it("should create a pool instance", () => {
+      expect(pool).toBeInstanceOf(ConnectionPool);
+    });
 
-describe('ConnectionPool', () => {
-    let pool: ConnectionPool;
-    let config: ConnectionPoolConfig;
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        config = {
-            host: 'localhost',
-            port: 3306,
-            user: 'root',
-            password: 'root',
-            database: 'testdb'
-        };
-        pool = new ConnectionPool(config);
-    });
-
-    describe('constructor', () => {
-        it('should create a pool instance', () => {
-            expect(pool).toBeInstanceOf(ConnectionPool);
-        });
-
-        it('should not be initialized by default', () => {
-            expect(pool.isInitialized()).toBe(false);
-        });
-
-        it('should not be closing by default', () => {
-            expect(pool.isClosing()).toBe(false);
-        });
-    });
-
-    describe('initialize', () => {
-        it('should initialize the pool', async () => {
-            await pool.initialize();
-            expect(pool.isInitialized()).toBe(true);
-        });
-
-        it('should not re-initialize if already initialized', async () => {
-            await pool.initialize();
-            await pool.initialize(); // Should not throw
-            expect(pool.isInitialized()).toBe(true);
-        });
-    });
-
-    describe('getConnection', () => {
-        it('should throw if pool not initialized', async () => {
-            await expect(pool.getConnection()).rejects.toThrow('Connection pool not initialized');
-        });
-
-        it('should return a connection after initialization', async () => {
-            await pool.initialize();
-            const connection = await pool.getConnection();
-            expect(connection).toBeDefined();
-        });
-
-        it('should throw if pool is shutting down', async () => {
-            await pool.initialize();
-            await pool.shutdown();
-            await expect(pool.getConnection()).rejects.toThrow();
-        });
-    });
-
-    describe('query', () => {
-        it('should throw if pool not initialized', async () => {
-            await expect(pool.query('SELECT 1')).rejects.toThrow('Connection pool not initialized');
-        });
-
-        it('should execute queries after initialization', async () => {
-            await pool.initialize();
-            const [rows, _fields] = await pool.query('SELECT 1');
-            expect(rows).toBeDefined();
-        });
-
-        it('should track query count', async () => {
-            await pool.initialize();
-            await pool.query('SELECT 1');
-            await pool.query('SELECT 2');
-            const stats = pool.getStats();
-            expect(stats.totalQueries).toBe(2);
-        });
-    });
-
-    describe('execute', () => {
-        it('should throw if pool not initialized', async () => {
-            await expect(pool.execute('SELECT ?', [1])).rejects.toThrow('Connection pool not initialized');
-        });
-
-        it('should execute prepared statements after initialization', async () => {
-            await pool.initialize();
-            const [rows, _fields] = await pool.execute('SELECT ?', [1]);
-            expect(rows).toBeDefined();
-        });
-
-        it('should track query count for execute', async () => {
-            await pool.initialize();
-            await pool.execute('SELECT 1');
-            const stats = pool.getStats();
-            expect(stats.totalQueries).toBe(1);
-        });
-    });
-
-    describe('getStats', () => {
-        it('should return stats even before initialization', () => {
-            const stats = pool.getStats();
-            expect(stats).toHaveProperty('total');
-            expect(stats).toHaveProperty('active');
-            expect(stats).toHaveProperty('idle');
-            expect(stats).toHaveProperty('waiting');
-            expect(stats).toHaveProperty('totalQueries');
-        });
-
-        it('should track active connections', async () => {
-            await pool.initialize();
-            const _conn = await pool.getConnection();
-            const stats = pool.getStats();
-            expect(stats.active).toBe(1);
-        });
-    });
-
-    describe('releaseConnection', () => {
-        it('should decrease active count', async () => {
-            await pool.initialize();
-            const conn = await pool.getConnection();
-            expect(pool.getStats().active).toBe(1);
-            pool.releaseConnection(conn);
-            expect(pool.getStats().active).toBe(0);
-        });
-
-        it('should not go below 0 active connections', async () => {
-            await pool.initialize();
-            const conn = await pool.getConnection();
-            pool.releaseConnection(conn);
-            pool.releaseConnection(conn); // Release twice
-            expect(pool.getStats().active).toBe(0);
-        });
-    });
-
-    describe('checkHealth', () => {
-        it('should return unhealthy if not initialized', async () => {
-            const health = await pool.checkHealth();
-            expect(health.connected).toBe(false);
-            expect(health.error).toContain('not initialized');
-        });
-
-        it('should return healthy after initialization', async () => {
-            await pool.initialize();
-            const health = await pool.checkHealth();
-            expect(health.connected).toBe(true);
-            expect(health.latencyMs).toBeDefined();
-            expect(health.version).toBe('8.0.35');
-        });
-
-        it('should include pool stats in health check', async () => {
-            await pool.initialize();
-            const health = await pool.checkHealth();
-            expect(health.poolStats).toBeDefined();
-        });
-    });
-
-    describe('shutdown', () => {
-        it('should do nothing if not initialized', async () => {
-            await pool.shutdown(); // Should not throw
-            expect(pool.isInitialized()).toBe(false);
-        });
-
-        it('should shutdown the pool', async () => {
-            await pool.initialize();
-            expect(pool.isInitialized()).toBe(true);
-            await pool.shutdown();
-            expect(pool.isClosing()).toBe(true);
-        });
-    });
-
-    describe('isInitialized', () => {
-        it('should return false before initialization', () => {
-            expect(pool.isInitialized()).toBe(false);
-        });
-
-        it('should return true after initialization', async () => {
-            await pool.initialize();
-            expect(pool.isInitialized()).toBe(true);
-        });
-    });
-
-    describe('isClosing', () => {
-        it('should return false initially', () => {
-            expect(pool.isClosing()).toBe(false);
-        });
-
-        it('should return true after shutdown starts', async () => {
-            await pool.initialize();
-            await pool.shutdown();
-            expect(pool.isClosing()).toBe(true);
-        });
+    it("should not be initialized by default", () => {
+      expect(pool.isInitialized()).toBe(false);
+    });
+
+    it("should not be closing by default", () => {
+      expect(pool.isClosing()).toBe(false);
+    });
+  });
+
+  describe("initialize", () => {
+    it("should initialize the pool", async () => {
+      await pool.initialize();
+      expect(pool.isInitialized()).toBe(true);
+    });
+
+    it("should not re-initialize if already initialized", async () => {
+      await pool.initialize();
+      await pool.initialize(); // Should not throw
+      expect(pool.isInitialized()).toBe(true);
+    });
+  });
+
+  describe("getConnection", () => {
+    it("should throw if pool not initialized", async () => {
+      await expect(pool.getConnection()).rejects.toThrow(
+        "Connection pool not initialized",
+      );
+    });
+
+    it("should return a connection after initialization", async () => {
+      await pool.initialize();
+      const connection = await pool.getConnection();
+      expect(connection).toBeDefined();
+    });
+
+    it("should throw if pool is shutting down", async () => {
+      await pool.initialize();
+      await pool.shutdown();
+      await expect(pool.getConnection()).rejects.toThrow();
+    });
+  });
+
+  describe("query", () => {
+    it("should throw if pool not initialized", async () => {
+      await expect(pool.query("SELECT 1")).rejects.toThrow(
+        "Connection pool not initialized",
+      );
+    });
+
+    it("should execute queries after initialization", async () => {
+      await pool.initialize();
+      const [rows, _fields] = await pool.query("SELECT 1");
+      expect(rows).toBeDefined();
+    });
+
+    it("should track query count", async () => {
+      await pool.initialize();
+      await pool.query("SELECT 1");
+      await pool.query("SELECT 2");
+      const stats = pool.getStats();
+      expect(stats.totalQueries).toBe(2);
+    });
+  });
+
+  describe("execute", () => {
+    it("should throw if pool not initialized", async () => {
+      await expect(pool.execute("SELECT ?", [1])).rejects.toThrow(
+        "Connection pool not initialized",
+      );
+    });
+
+    it("should execute prepared statements after initialization", async () => {
+      await pool.initialize();
+      const [rows, _fields] = await pool.execute("SELECT ?", [1]);
+      expect(rows).toBeDefined();
+    });
+
+    it("should track query count for execute", async () => {
+      await pool.initialize();
+      await pool.execute("SELECT 1");
+      const stats = pool.getStats();
+      expect(stats.totalQueries).toBe(1);
+    });
+  });
+
+  describe("getStats", () => {
+    it("should return stats even before initialization", () => {
+      const stats = pool.getStats();
+      expect(stats).toHaveProperty("total");
+      expect(stats).toHaveProperty("active");
+      expect(stats).toHaveProperty("idle");
+      expect(stats).toHaveProperty("waiting");
+      expect(stats).toHaveProperty("totalQueries");
+    });
+
+    it("should track active connections", async () => {
+      await pool.initialize();
+      const _conn = await pool.getConnection();
+      const stats = pool.getStats();
+      expect(stats.active).toBe(1);
+    });
+  });
+
+  describe("releaseConnection", () => {
+    it("should decrease active count", async () => {
+      await pool.initialize();
+      const conn = await pool.getConnection();
+      expect(pool.getStats().active).toBe(1);
+      pool.releaseConnection(conn);
+      expect(pool.getStats().active).toBe(0);
     });
-});
 
-describe('ConnectionPool with SSL', () => {
-    it('should handle boolean SSL config', async () => {
-        const pool = new ConnectionPool({
-            host: 'localhost',
-            port: 3306,
-            user: 'root',
-            password: 'root',
-            database: 'testdb',
-            ssl: true
-        });
-        await pool.initialize();
-        expect(pool.isInitialized()).toBe(true);
-    });
-
-    it('should handle boolean SSL config false', async () => {
-        const pool = new ConnectionPool({
-            host: 'localhost',
-            port: 3306,
-            user: 'root',
-            password: 'root',
-            database: 'testdb',
-            ssl: false
-        });
-        await pool.initialize();
-        expect(pool.isInitialized()).toBe(true);
-    });
-
-    it('should handle SSL options config', async () => {
-        const pool = new ConnectionPool({
-            host: 'localhost',
-            port: 3306,
-            user: 'root',
-            password: 'root',
-            database: 'testdb',
-            ssl: { rejectUnauthorized: false }
-        });
-        await pool.initialize();
-        expect(pool.isInitialized()).toBe(true);
+    it("should not go below 0 active connections", async () => {
+      await pool.initialize();
+      const conn = await pool.getConnection();
+      pool.releaseConnection(conn);
+      pool.releaseConnection(conn); // Release twice
+      expect(pool.getStats().active).toBe(0);
     });
+  });
+
+  describe("checkHealth", () => {
+    it("should return unhealthy if not initialized", async () => {
+      const health = await pool.checkHealth();
+      expect(health.connected).toBe(false);
+      expect(health.error).toContain("not initialized");
+    });
+
+    it("should return healthy after initialization", async () => {
+      await pool.initialize();
+      const health = await pool.checkHealth();
+      expect(health.connected).toBe(true);
+      expect(health.latencyMs).toBeDefined();
+      expect(health.version).toBe("8.0.35");
+    });
+
+    it("should include pool stats in health check", async () => {
+      await pool.initialize();
+      const health = await pool.checkHealth();
+      expect(health.poolStats).toBeDefined();
+    });
+  });
+
+  describe("shutdown", () => {
+    it("should do nothing if not initialized", async () => {
+      await pool.shutdown(); // Should not throw
+      expect(pool.isInitialized()).toBe(false);
+    });
+
+    it("should shutdown the pool", async () => {
+      await pool.initialize();
+      expect(pool.isInitialized()).toBe(true);
+      await pool.shutdown();
+      expect(pool.isClosing()).toBe(true);
+    });
+  });
+
+  describe("isInitialized", () => {
+    it("should return false before initialization", () => {
+      expect(pool.isInitialized()).toBe(false);
+    });
+
+    it("should return true after initialization", async () => {
+      await pool.initialize();
+      expect(pool.isInitialized()).toBe(true);
+    });
+  });
+
+  describe("isClosing", () => {
+    it("should return false initially", () => {
+      expect(pool.isClosing()).toBe(false);
+    });
+
+    it("should return true after shutdown starts", async () => {
+      await pool.initialize();
+      await pool.shutdown();
+      expect(pool.isClosing()).toBe(true);
+    });
+  });
 });
 
-describe('ConnectionPool with custom pool config', () => {
-    it('should apply custom connection limit', async () => {
-        const pool = new ConnectionPool({
-            host: 'localhost',
-            port: 3306,
-            user: 'root',
-            password: 'root',
-            database: 'testdb',
-            pool: {
-                connectionLimit: 20,
-                waitForConnections: true,
-                queueLimit: 10
-            }
-        });
-        await pool.initialize();
-        const stats = pool.getStats();
-        expect(stats.total).toBe(20);
+describe("ConnectionPool with SSL", () => {
+  it("should handle boolean SSL config", async () => {
+    const pool = new ConnectionPool({
+      host: "localhost",
+      port: 3306,
+      user: "root",
+      password: "root",
+      database: "testdb",
+      ssl: true,
+    });
+    await pool.initialize();
+    expect(pool.isInitialized()).toBe(true);
+  });
+
+  it("should handle boolean SSL config false", async () => {
+    const pool = new ConnectionPool({
+      host: "localhost",
+      port: 3306,
+      user: "root",
+      password: "root",
+      database: "testdb",
+      ssl: false,
     });
+    await pool.initialize();
+    expect(pool.isInitialized()).toBe(true);
+  });
+
+  it("should handle SSL options config", async () => {
+    const pool = new ConnectionPool({
+      host: "localhost",
+      port: 3306,
+      user: "root",
+      password: "root",
+      database: "testdb",
+      ssl: { rejectUnauthorized: false },
+    });
+    await pool.initialize();
+    expect(pool.isInitialized()).toBe(true);
+  });
 });
 
-describe('ConnectionPool Error Handling', () => {
-    it('should handle initialization failure', async () => {
-        const createPoolSpy = vi.spyOn(mysql, 'createPool');
-        createPoolSpy.mockImplementationOnce(() => {
-            throw new Error('Connection refused');
-        });
-
-        const pool = new ConnectionPool({
-            host: 'localhost',
-            port: 3306,
-            user: 'root',
-            password: 'root',
-            database: 'testdb'
-        });
-
-        await expect(pool.initialize()).rejects.toThrow('Failed to initialize connection pool');
+describe("ConnectionPool with custom pool config", () => {
+  it("should apply custom connection limit", async () => {
+    const pool = new ConnectionPool({
+      host: "localhost",
+      port: 3306,
+      user: "root",
+      password: "root",
+      database: "testdb",
+      pool: {
+        connectionLimit: 20,
+        waitForConnections: true,
+        queueLimit: 10,
+      },
     });
+    await pool.initialize();
+    const stats = pool.getStats();
+    expect(stats.total).toBe(20);
+  });
+});
 
-    it('should fail if pool not initialized', async () => {
-        const pool = new ConnectionPool({
-            host: 'localhost',
-            port: 3306,
-            user: 'root',
-            password: 'root',
-            database: 'testdb'
-        });
-
-        // Skip initialize
-
-        await expect(pool.getConnection()).rejects.toThrow('Connection pool not initialized');
-        await expect(pool.query('SELECT 1')).rejects.toThrow('Connection pool not initialized');
-        await expect(pool.execute('SELECT 1')).rejects.toThrow('Connection pool not initialized');
-    });
-
-    it('should handle getConnection failure', async () => {
-        const pool = new ConnectionPool({
-            host: 'localhost',
-            port: 3306,
-            user: 'root',
-            password: 'root',
-            database: 'testdb'
-        });
-        await pool.initialize();
-
-        // Spy on the internal pool's getConnection
-        // We cast to any to access the private pool property or just rely on the mock factory
-        const internalPool = (pool as any).pool;
-        vi.spyOn(internalPool, 'getConnection').mockRejectedValueOnce(new Error('Pool exhausted'));
-
-        await expect(pool.getConnection()).rejects.toThrow('Failed to get connection: Pool exhausted');
-    });
-
-    it('should handle query failure', async () => {
-        const pool = new ConnectionPool({
-            host: 'localhost',
-            port: 3306,
-            user: 'root',
-            password: 'root',
-            database: 'testdb'
-        });
-        await pool.initialize();
-
-        const internalPool = (pool as any).pool;
-        vi.spyOn(internalPool, 'query').mockRejectedValueOnce(new Error('Query failed'));
-
-        await expect(pool.query('SELECT 1')).rejects.toThrow('Query failed: Query failed');
-    });
-
-    it('should handle execute failure', async () => {
-        const pool = new ConnectionPool({
-            host: 'localhost',
-            port: 3306,
-            user: 'root',
-            password: 'root',
-            database: 'testdb'
-        });
-        await pool.initialize();
-
-        const internalPool = (pool as any).pool;
-        vi.spyOn(internalPool, 'execute').mockRejectedValueOnce(new Error('Execution failed'));
-
-        await expect(pool.execute('UPDATE users SET name = ?', ['test'])).rejects.toThrow('Execute failed: Execution failed');
-    });
-
-    it('should fail if shutting down', async () => {
-        const pool = new ConnectionPool({
-            host: 'localhost',
-            port: 3306,
-            user: 'root',
-            password: 'root',
-            database: 'testdb'
-        });
-        await pool.initialize();
-
-        // Force shutting down state
-        (pool as any).isShuttingDown = true;
-
-        await expect(pool.getConnection()).rejects.toThrow('Connection pool is shutting down');
-        await expect(pool.getConnection()).rejects.toThrow('Connection pool is shutting down');
-    });
-
-    it('should handle shutdown failure', async () => {
-        const pool = new ConnectionPool({
-            host: 'localhost',
-            port: 3306,
-            user: 'root',
-            password: 'root',
-            database: 'testdb'
-        });
-        await pool.initialize();
-
-        const internalPool = (pool as any).pool;
-        vi.spyOn(internalPool, 'end').mockRejectedValueOnce(new Error('Forced error'));
+describe("ConnectionPool Error Handling", () => {
+  it("should handle initialization failure", async () => {
+    const createPoolSpy = vi.spyOn(mysql, "createPool");
+    createPoolSpy.mockImplementationOnce(() => {
+      throw new Error("Connection refused");
+    });
 
-        await expect(pool.shutdown()).rejects.toThrow('Forced error');
-    });
+    const pool = new ConnectionPool({
+      host: "localhost",
+      port: 3306,
+      user: "root",
+      password: "root",
+      database: "testdb",
+    });
 
-    it('should handle releaseConnection failure', async () => {
-        const pool = new ConnectionPool({
-            host: 'localhost',
-            port: 3306,
-            user: 'root',
-            password: 'root',
-            database: 'testdb'
-        });
-        await pool.initialize();
+    await expect(pool.initialize()).rejects.toThrow(
+      "Failed to initialize connection pool",
+    );
+  });
+
+  it("should fail if pool not initialized", async () => {
+    const pool = new ConnectionPool({
+      host: "localhost",
+      port: 3306,
+      user: "root",
+      password: "root",
+      database: "testdb",
+    });
 
-        const connection = await pool.getConnection();
+    // Skip initialize
+
+    await expect(pool.getConnection()).rejects.toThrow(
+      "Connection pool not initialized",
+    );
+    await expect(pool.query("SELECT 1")).rejects.toThrow(
+      "Connection pool not initialized",
+    );
+    await expect(pool.execute("SELECT 1")).rejects.toThrow(
+      "Connection pool not initialized",
+    );
+  });
+
+  it("should handle getConnection failure", async () => {
+    const pool = new ConnectionPool({
+      host: "localhost",
+      port: 3306,
+      user: "root",
+      password: "root",
+      database: "testdb",
+    });
+    await pool.initialize();
+
+    // Spy on the internal pool's getConnection
+    // We cast to any to access the private pool property or just rely on the mock factory
+    const internalPool = (pool as any).pool;
+    vi.spyOn(internalPool, "getConnection").mockRejectedValueOnce(
+      new Error("Pool exhausted"),
+    );
+
+    await expect(pool.getConnection()).rejects.toThrow(
+      "Failed to get connection: Pool exhausted",
+    );
+  });
+
+  it("should handle query failure", async () => {
+    const pool = new ConnectionPool({
+      host: "localhost",
+      port: 3306,
+      user: "root",
+      password: "root",
+      database: "testdb",
+    });
+    await pool.initialize();
+
+    const internalPool = (pool as any).pool;
+    vi.spyOn(internalPool, "query").mockRejectedValueOnce(
+      new Error("Query failed"),
+    );
+
+    await expect(pool.query("SELECT 1")).rejects.toThrow(
+      "Query failed: Query failed",
+    );
+  });
+
+  it("should handle execute failure", async () => {
+    const pool = new ConnectionPool({
+      host: "localhost",
+      port: 3306,
+      user: "root",
+      password: "root",
+      database: "testdb",
+    });
+    await pool.initialize();
+
+    const internalPool = (pool as any).pool;
+    vi.spyOn(internalPool, "execute").mockRejectedValueOnce(
+      new Error("Execution failed"),
+    );
+
+    await expect(
+      pool.execute("UPDATE users SET name = ?", ["test"]),
+    ).rejects.toThrow("Execute failed: Execution failed");
+  });
+
+  it("should fail if shutting down", async () => {
+    const pool = new ConnectionPool({
+      host: "localhost",
+      port: 3306,
+      user: "root",
+      password: "root",
+      database: "testdb",
+    });
+    await pool.initialize();
+
+    // Force shutting down state
+    (pool as any).isShuttingDown = true;
+
+    await expect(pool.getConnection()).rejects.toThrow(
+      "Connection pool is shutting down",
+    );
+    await expect(pool.getConnection()).rejects.toThrow(
+      "Connection pool is shutting down",
+    );
+  });
+
+  it("should handle shutdown failure", async () => {
+    const pool = new ConnectionPool({
+      host: "localhost",
+      port: 3306,
+      user: "root",
+      password: "root",
+      database: "testdb",
+    });
+    await pool.initialize();
+
+    const internalPool = (pool as any).pool;
+    vi.spyOn(internalPool, "end").mockRejectedValueOnce(
+      new Error("Forced error"),
+    );
+
+    await expect(pool.shutdown()).rejects.toThrow("Forced error");
+  });
+
+  it("should handle releaseConnection failure", async () => {
+    const pool = new ConnectionPool({
+      host: "localhost",
+      port: 3306,
+      user: "root",
+      password: "root",
+      database: "testdb",
+    });
+    await pool.initialize();
 
-        // Mock release to throw
-        vi.spyOn(connection, 'release').mockImplementationOnce(() => {
-            throw new Error('Release failed');
-        });
-
-        // Should not throw, but log error
-        pool.releaseConnection(connection);
-    });
-
-    it('should handle checkHealth failure', async () => {
-        const pool = new ConnectionPool({
-            host: 'localhost',
-            port: 3306,
-            user: 'root',
-            password: 'root',
-            database: 'testdb'
-        });
-        await pool.initialize();
+    const connection = await pool.getConnection();
 
-        const internalPool = (pool as any).pool;
-        vi.spyOn(internalPool, 'getConnection').mockRejectedValueOnce(new Error('Health check failed'));
+    // Mock release to throw
+    vi.spyOn(connection, "release").mockImplementationOnce(() => {
+      throw new Error("Release failed");
+    });
 
-        const health = await pool.checkHealth();
-        expect(health.connected).toBe(false);
-        expect(health.error).toContain('Health check failed');
+    // Should not throw, but log error
+    pool.releaseConnection(connection);
+  });
+
+  it("should handle checkHealth failure", async () => {
+    const pool = new ConnectionPool({
+      host: "localhost",
+      port: 3306,
+      user: "root",
+      password: "root",
+      database: "testdb",
     });
+    await pool.initialize();
+
+    const internalPool = (pool as any).pool;
+    vi.spyOn(internalPool, "getConnection").mockRejectedValueOnce(
+      new Error("Health check failed"),
+    );
+
+    const health = await pool.checkHealth();
+    expect(health.connected).toBe(false);
+    expect(health.error).toContain("Health check failed");
+  });
 });