/**
* 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";
// 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),
};
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),
},
};
});
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);
});
});
});
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 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 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",
);
});
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"),
);
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();
const connection = await pool.getConnection();
// 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 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");
});
});
