@neverinfamous/mysql-mcp 2.1.0 → 2.2.0

package/src/adapters/mysql/tools/__tests__/router.test.ts

@@ -1,603 +1,707 @@
 /**
  * mysql-mcp - Router Tools Unit Tests
- * 
+ *
  * Tests for router tool definitions, annotations, and handler execution.
  * Mocks https module to test MySQL Router REST API calls.
  */
 
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { getRouterTools } from '../router.js';
-import type { MySQLAdapter } from '../../MySQLAdapter.js';
-import { createMockMySQLAdapter, createMockRequestContext } from '../../../../__tests__/mocks/index.js';
-import { EventEmitter } from 'events';
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { getRouterTools } from "../router.js";
+import type { MySQLAdapter } from "../../MySQLAdapter.js";
+import {
+  createMockMySQLAdapter,
+  createMockRequestContext,
+} from "../../../../__tests__/mocks/index.js";
+import { EventEmitter } from "events";
 
 // Mock https module
-vi.mock('node:https', () => ({
-    default: {
-        request: vi.fn()
-    }
+vi.mock("node:https", () => ({
+  default: {
+    request: vi.fn(),
+  },
 }));
 
-import https from 'node:https';
+import https from "node:https";
 const mockRequest = https.request as ReturnType<typeof vi.fn>;
 
-describe('getRouterTools', () => {
-    let tools: ReturnType<typeof getRouterTools>;
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        tools = getRouterTools(createMockMySQLAdapter() as unknown as MySQLAdapter);
-    });
+describe("getRouterTools", () => {
+  let tools: ReturnType<typeof getRouterTools>;
 
-    it('should return 9 router tools', () => {
-        expect(tools).toHaveLength(9);
-    });
+  beforeEach(() => {
+    vi.clearAllMocks();
+    tools = getRouterTools(createMockMySQLAdapter() as unknown as MySQLAdapter);
+  });
 
-    it('should have router group for all tools', () => {
-        for (const tool of tools) {
-            expect(tool.group).toBe('router');
-        }
-    });
+  it("should return 9 router tools", () => {
+    expect(tools).toHaveLength(9);
+  });
 
-    it('should have handler functions for all tools', () => {
-        for (const tool of tools) {
-            expect(typeof tool.handler).toBe('function');
-        }
-    });
+  it("should have router group for all tools", () => {
+    for (const tool of tools) {
+      expect(tool.group).toBe("router");
+    }
+  });
 
-    it('should have inputSchema for all tools', () => {
-        for (const tool of tools) {
-            expect(tool.inputSchema).toBeDefined();
-        }
-    });
+  it("should have handler functions for all tools", () => {
+    for (const tool of tools) {
+      expect(typeof tool.handler).toBe("function");
+    }
+  });
 
-    it('should include all expected tool names', () => {
-        const toolNames = tools.map(t => t.name);
-        expect(toolNames).toContain('mysql_router_status');
-        expect(toolNames).toContain('mysql_router_routes');
-        expect(toolNames).toContain('mysql_router_route_status');
-        expect(toolNames).toContain('mysql_router_route_health');
-        expect(toolNames).toContain('mysql_router_route_connections');
-        expect(toolNames).toContain('mysql_router_route_destinations');
-        expect(toolNames).toContain('mysql_router_route_blocked_hosts');
-        expect(toolNames).toContain('mysql_router_metadata_status');
-        expect(toolNames).toContain('mysql_router_pool_status');
-    });
+  it("should have inputSchema for all tools", () => {
+    for (const tool of tools) {
+      expect(tool.inputSchema).toBeDefined();
+    }
+  });
+
+  it("should include all expected tool names", () => {
+    const toolNames = tools.map((t) => t.name);
+    expect(toolNames).toContain("mysql_router_status");
+    expect(toolNames).toContain("mysql_router_routes");
+    expect(toolNames).toContain("mysql_router_route_status");
+    expect(toolNames).toContain("mysql_router_route_health");
+    expect(toolNames).toContain("mysql_router_route_connections");
+    expect(toolNames).toContain("mysql_router_route_destinations");
+    expect(toolNames).toContain("mysql_router_route_blocked_hosts");
+    expect(toolNames).toContain("mysql_router_metadata_status");
+    expect(toolNames).toContain("mysql_router_pool_status");
+  });
 });
 
-describe('Tool Structure Validation', () => {
-    let tools: ReturnType<typeof getRouterTools>;
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        tools = getRouterTools(createMockMySQLAdapter() as unknown as MySQLAdapter);
-    });
-
-    it('mysql_router_status should have correct structure', () => {
-        const tool = tools.find(t => t.name === 'mysql_router_status')!;
-        expect(tool.name).toBe('mysql_router_status');
-        expect(tool.description).toBeDefined();
-        expect(tool.annotations?.readOnlyHint).toBe(true);
-        expect(tool.annotations?.openWorldHint).toBe(true);
-    });
-
-    it('all router tools should be read-only', () => {
-        for (const tool of tools) {
-            expect(tool.annotations?.readOnlyHint).toBe(true);
-        }
-    });
+describe("Tool Structure Validation", () => {
+  let tools: ReturnType<typeof getRouterTools>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    tools = getRouterTools(createMockMySQLAdapter() as unknown as MySQLAdapter);
+  });
+
+  it("mysql_router_status should have correct structure", () => {
+    const tool = tools.find((t) => t.name === "mysql_router_status")!;
+    expect(tool.name).toBe("mysql_router_status");
+    expect(tool.description).toBeDefined();
+    expect(tool.annotations?.readOnlyHint).toBe(true);
+    expect(tool.annotations?.openWorldHint).toBe(true);
+  });
+
+  it("all router tools should be read-only", () => {
+    for (const tool of tools) {
+      expect(tool.annotations?.readOnlyHint).toBe(true);
+    }
+  });
 
-    it('all router tools should have correct requiredScopes', () => {
-        for (const tool of tools) {
-            expect(tool.requiredScopes).toContain('read');
-        }
-    });
+  it("all router tools should have correct requiredScopes", () => {
+    for (const tool of tools) {
+      expect(tool.requiredScopes).toContain("read");
+    }
+  });
 
-    it('all tools should have openWorldHint true', () => {
-        for (const tool of tools) {
-            expect(tool.annotations?.openWorldHint).toBe(true);
-        }
-    });
+  it("all tools should have openWorldHint true", () => {
+    for (const tool of tools) {
+      expect(tool.annotations?.openWorldHint).toBe(true);
+    }
+  });
 
-    it('all tools should have idempotentHint true', () => {
-        for (const tool of tools) {
-            expect(tool.annotations?.idempotentHint).toBe(true);
-        }
-    });
+  it("all tools should have idempotentHint true", () => {
+    for (const tool of tools) {
+      expect(tool.annotations?.idempotentHint).toBe(true);
+    }
+  });
 });
 
-describe('Handler Execution', () => {
-    let tools: ReturnType<typeof getRouterTools>;
-    let mockContext: ReturnType<typeof createMockRequestContext>;
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        tools = getRouterTools(createMockMySQLAdapter() as unknown as MySQLAdapter);
-        mockContext = createMockRequestContext();
-    });
-
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-
-    // Helper to mock successful https response
-    const mockHttpsResponse = (data: unknown, statusCode = 200) => {
-        const mockReq = new EventEmitter() as EventEmitter & { end: () => void; destroy: () => void };
-        mockReq.end = vi.fn();
-        mockReq.destroy = vi.fn();
-
-        mockRequest.mockImplementation((_options, callback) => {
-            const mockRes = new EventEmitter() as EventEmitter & { statusCode: number; statusMessage: string };
-            mockRes.statusCode = statusCode;
-            mockRes.statusMessage = statusCode === 200 ? 'OK' : 'Error';
-
-            setImmediate(() => {
-                callback?.(mockRes);
-                mockRes.emit('data', JSON.stringify(data));
-                mockRes.emit('end');
-            });
-
-            return mockReq;
-        });
+describe("Handler Execution", () => {
+  let tools: ReturnType<typeof getRouterTools>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    tools = getRouterTools(createMockMySQLAdapter() as unknown as MySQLAdapter);
+    mockContext = createMockRequestContext();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  // Helper to mock successful https response
+  const mockHttpsResponse = (data: unknown, statusCode = 200) => {
+    const mockReq = new EventEmitter() as EventEmitter & {
+      end: () => void;
+      destroy: () => void;
     };
-
-    describe('mysql_router_status', () => {
-        it('should fetch router status and return result', async () => {
-            const mockStatus = {
-                processId: 1234,
-                version: '8.0.35',
-                hostname: 'router-host',
-                timeStarted: '2024-01-01T00:00:00Z'
-            };
-            mockHttpsResponse(mockStatus);
-
-            const tool = tools.find(t => t.name === 'mysql_router_status')!;
-            const result = await tool.handler({}, mockContext);
-
-            expect(mockRequest).toHaveBeenCalled();
-            const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
-            expect(options.method).toBe('GET');
-            expect(options.path).toContain('/router/status');
-            expect(result).toEqual({
-                success: true,
-                status: mockStatus
-            });
-        });
-    });
-
-    describe('mysql_router_routes', () => {
-        it('should fetch all routes', async () => {
-            const mockRoutes = {
-                items: [
-                    { name: 'bootstrap_ro' },
-                    { name: 'bootstrap_rw' }
-                ]
-            };
-            mockHttpsResponse(mockRoutes);
-
-            const tool = tools.find(t => t.name === 'mysql_router_routes')!;
-            const result = await tool.handler({}, mockContext);
-
-            expect(mockRequest).toHaveBeenCalled();
-            const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
-            expect(options.path).toContain('/routes');
-            expect(result).toEqual({
-                success: true,
-                routes: mockRoutes
-            });
-        });
-    });
-
-    describe('mysql_router_route_status', () => {
-        it('should fetch status for specific route', async () => {
-            const mockRouteStatus = {
-                activeConnections: 5,
-                totalConnections: 100,
-                blockedHosts: 0
-            };
-            mockHttpsResponse(mockRouteStatus);
-
-            const tool = tools.find(t => t.name === 'mysql_router_route_status')!;
-            const result = await tool.handler({ routeName: 'bootstrap_ro' }, mockContext);
-
-            expect(mockRequest).toHaveBeenCalled();
-            const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
-            expect(options.path).toContain('/routes/bootstrap_ro/status');
-            expect(result).toEqual({
-                success: true,
-                routeName: 'bootstrap_ro',
-                status: mockRouteStatus
-            });
-        });
-
-        it('should URL-encode route names', async () => {
-            mockHttpsResponse({});
-
-            const tool = tools.find(t => t.name === 'mysql_router_route_status')!;
-            await tool.handler({ routeName: 'route/with/slashes' }, mockContext);
-
-            const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
-            expect(options.path).toContain('route%2Fwith%2Fslashes');
-        });
-    });
-
-    describe('mysql_router_route_health', () => {
-        it('should check route health', async () => {
-            const mockHealth = { isAlive: true };
-            mockHttpsResponse(mockHealth);
-
-            const tool = tools.find(t => t.name === 'mysql_router_route_health')!;
-            const result = await tool.handler({ routeName: 'bootstrap_ro' }, mockContext);
-
-            expect(mockRequest).toHaveBeenCalled();
-            const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
-            expect(options.path).toContain('/routes/bootstrap_ro/health');
-            expect(result).toEqual({
-                success: true,
-                routeName: 'bootstrap_ro',
-                health: mockHealth
-            });
-        });
-    });
-
-    describe('mysql_router_route_connections', () => {
-        it('should list active connections', async () => {
-            const mockConnections = {
-                items: [
-                    { sourceAddress: '192.168.1.1', destinationAddress: '10.0.0.1', bytesIn: 1024 }
-                ]
-            };
-            mockHttpsResponse(mockConnections);
-
-            const tool = tools.find(t => t.name === 'mysql_router_route_connections')!;
-            const result = await tool.handler({ routeName: 'bootstrap_rw' }, mockContext);
-
-            expect(mockRequest).toHaveBeenCalled();
-            const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
-            expect(options.path).toContain('/routes/bootstrap_rw/connections');
-            expect(result).toEqual({
-                success: true,
-                routeName: 'bootstrap_rw',
-                connections: mockConnections
-            });
-        });
-    });
-
-    describe('mysql_router_route_destinations', () => {
-        it('should list backend destinations', async () => {
-            const mockDestinations = {
-                items: [
-                    { address: 'mysql-1.example.com', port: 3306 },
-                    { address: 'mysql-2.example.com', port: 3306 }
-                ]
-            };
-            mockHttpsResponse(mockDestinations);
-
-            const tool = tools.find(t => t.name === 'mysql_router_route_destinations')!;
-            const result = await tool.handler({ routeName: 'bootstrap_ro' }, mockContext);
-
-            expect(mockRequest).toHaveBeenCalled();
-            const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
-            expect(options.path).toContain('/routes/bootstrap_ro/destinations');
-            expect(result).toEqual({
-                success: true,
-                routeName: 'bootstrap_ro',
-                destinations: mockDestinations
-            });
-        });
-    });
-
-    describe('mysql_router_route_blocked_hosts', () => {
-        it('should list blocked hosts', async () => {
-            const mockBlockedHosts = {
-                items: [
-                    { address: '192.168.1.100' }
-                ]
-            };
-            mockHttpsResponse(mockBlockedHosts);
-
-            const tool = tools.find(t => t.name === 'mysql_router_route_blocked_hosts')!;
-            const result = await tool.handler({ routeName: 'bootstrap_rw' }, mockContext);
-
-            expect(mockRequest).toHaveBeenCalled();
-            const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
-            expect(options.path).toContain('/routes/bootstrap_rw/blockedHosts');
-            expect(result).toEqual({
-                success: true,
-                routeName: 'bootstrap_rw',
-                blockedHosts: mockBlockedHosts
-            });
-        });
-    });
-
-    describe('mysql_router_metadata_status', () => {
-        it('should fetch metadata cache status', async () => {
-            const mockMetadata = {
-                refreshTotal: 100,
-                refreshSucceeded: 99,
-                lastRefreshHostName: 'mysql-primary.example.com'
-            };
-            mockHttpsResponse(mockMetadata);
-
-            const tool = tools.find(t => t.name === 'mysql_router_metadata_status')!;
-            const result = await tool.handler({ metadataName: 'my_cluster' }, mockContext);
-
-            expect(mockRequest).toHaveBeenCalled();
-            const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
-            expect(options.path).toContain('/metadata/my_cluster/status');
-            expect(result).toEqual({
-                success: true,
-                metadataName: 'my_cluster',
-                status: mockMetadata
-            });
-        });
-    });
-
-    describe('mysql_router_pool_status', () => {
-        it('should fetch connection pool status', async () => {
-            const mockPoolStatus = {
-                reusedConnections: 50,
-                idleServerConnections: 10
-            };
-            mockHttpsResponse(mockPoolStatus);
-
-            const tool = tools.find(t => t.name === 'mysql_router_pool_status')!;
-            const result = await tool.handler({ poolName: 'default' }, mockContext);
-
-            expect(mockRequest).toHaveBeenCalled();
-            const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
-            expect(options.path).toContain('/connection_pool/default/status');
-            expect(result).toEqual({
-                success: true,
-                poolName: 'default',
-                status: mockPoolStatus
-            });
-        });
-    });
+    mockReq.end = vi.fn();
+    mockReq.destroy = vi.fn();
+
+    mockRequest.mockImplementation((_options, callback) => {
+      const mockRes = new EventEmitter() as EventEmitter & {
+        statusCode: number;
+        statusMessage: string;
+      };
+      mockRes.statusCode = statusCode;
+      mockRes.statusMessage = statusCode === 200 ? "OK" : "Error";
+
+      setImmediate(() => {
+        callback?.(mockRes);
+        mockRes.emit("data", JSON.stringify(data));
+        mockRes.emit("end");
+      });
+
+      return mockReq;
+    });
+  };
+
+  describe("mysql_router_status", () => {
+    it("should fetch router status and return result", async () => {
+      const mockStatus = {
+        processId: 1234,
+        version: "8.0.35",
+        hostname: "router-host",
+        timeStarted: "2024-01-01T00:00:00Z",
+      };
+      mockHttpsResponse(mockStatus);
+
+      const tool = tools.find((t) => t.name === "mysql_router_status")!;
+      const result = await tool.handler({}, mockContext);
+
+      expect(mockRequest).toHaveBeenCalled();
+      const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
+      expect(options.method).toBe("GET");
+      expect(options.path).toContain("/router/status");
+      expect(result).toEqual({
+        success: true,
+        status: mockStatus,
+      });
+    });
+  });
+
+  describe("mysql_router_routes", () => {
+    it("should fetch all routes", async () => {
+      const mockRoutes = {
+        items: [{ name: "bootstrap_ro" }, { name: "bootstrap_rw" }],
+      };
+      mockHttpsResponse(mockRoutes);
+
+      const tool = tools.find((t) => t.name === "mysql_router_routes")!;
+      const result = await tool.handler({}, mockContext);
+
+      expect(mockRequest).toHaveBeenCalled();
+      const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
+      expect(options.path).toContain("/routes");
+      expect(result).toEqual({
+        success: true,
+        routes: mockRoutes,
+      });
+    });
+  });
+
+  describe("mysql_router_route_status", () => {
+    it("should fetch status for specific route", async () => {
+      const mockRouteStatus = {
+        activeConnections: 5,
+        totalConnections: 100,
+        blockedHosts: 0,
+      };
+      mockHttpsResponse(mockRouteStatus);
+
+      const tool = tools.find((t) => t.name === "mysql_router_route_status")!;
+      const result = await tool.handler(
+        { routeName: "bootstrap_ro" },
+        mockContext,
+      );
+
+      expect(mockRequest).toHaveBeenCalled();
+      const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
+      expect(options.path).toContain("/routes/bootstrap_ro/status");
+      expect(result).toEqual({
+        success: true,
+        routeName: "bootstrap_ro",
+        status: mockRouteStatus,
+      });
+    });
+
+    it("should URL-encode route names", async () => {
+      mockHttpsResponse({});
+
+      const tool = tools.find((t) => t.name === "mysql_router_route_status")!;
+      await tool.handler({ routeName: "route/with/slashes" }, mockContext);
+
+      const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
+      expect(options.path).toContain("route%2Fwith%2Fslashes");
+    });
+  });
+
+  describe("mysql_router_route_health", () => {
+    it("should check route health", async () => {
+      const mockHealth = { isAlive: true };
+      mockHttpsResponse(mockHealth);
+
+      const tool = tools.find((t) => t.name === "mysql_router_route_health")!;
+      const result = await tool.handler(
+        { routeName: "bootstrap_ro" },
+        mockContext,
+      );
+
+      expect(mockRequest).toHaveBeenCalled();
+      const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
+      expect(options.path).toContain("/routes/bootstrap_ro/health");
+      expect(result).toEqual({
+        success: true,
+        routeName: "bootstrap_ro",
+        health: mockHealth,
+      });
+    });
+  });
+
+  describe("mysql_router_route_connections", () => {
+    it("should list active connections", async () => {
+      const mockConnections = {
+        items: [
+          {
+            sourceAddress: "192.168.1.1",
+            destinationAddress: "10.0.0.1",
+            bytesIn: 1024,
+          },
+        ],
+      };
+      mockHttpsResponse(mockConnections);
+
+      const tool = tools.find(
+        (t) => t.name === "mysql_router_route_connections",
+      )!;
+      const result = await tool.handler(
+        { routeName: "bootstrap_rw" },
+        mockContext,
+      );
+
+      expect(mockRequest).toHaveBeenCalled();
+      const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
+      expect(options.path).toContain("/routes/bootstrap_rw/connections");
+      expect(result).toEqual({
+        success: true,
+        routeName: "bootstrap_rw",
+        connections: mockConnections,
+      });
+    });
+  });
+
+  describe("mysql_router_route_destinations", () => {
+    it("should list backend destinations", async () => {
+      const mockDestinations = {
+        items: [
+          { address: "mysql-1.example.com", port: 3306 },
+          { address: "mysql-2.example.com", port: 3306 },
+        ],
+      };
+      mockHttpsResponse(mockDestinations);
+
+      const tool = tools.find(
+        (t) => t.name === "mysql_router_route_destinations",
+      )!;
+      const result = await tool.handler(
+        { routeName: "bootstrap_ro" },
+        mockContext,
+      );
+
+      expect(mockRequest).toHaveBeenCalled();
+      const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
+      expect(options.path).toContain("/routes/bootstrap_ro/destinations");
+      expect(result).toEqual({
+        success: true,
+        routeName: "bootstrap_ro",
+        destinations: mockDestinations,
+      });
+    });
+  });
+
+  describe("mysql_router_route_blocked_hosts", () => {
+    it("should list blocked hosts", async () => {
+      const mockBlockedHosts = {
+        items: [{ address: "192.168.1.100" }],
+      };
+      mockHttpsResponse(mockBlockedHosts);
+
+      const tool = tools.find(
+        (t) => t.name === "mysql_router_route_blocked_hosts",
+      )!;
+      const result = await tool.handler(
+        { routeName: "bootstrap_rw" },
+        mockContext,
+      );
+
+      expect(mockRequest).toHaveBeenCalled();
+      const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
+      expect(options.path).toContain("/routes/bootstrap_rw/blockedHosts");
+      expect(result).toEqual({
+        success: true,
+        routeName: "bootstrap_rw",
+        blockedHosts: mockBlockedHosts,
+      });
+    });
+  });
+
+  describe("mysql_router_metadata_status", () => {
+    it("should fetch metadata cache status", async () => {
+      const mockMetadata = {
+        refreshTotal: 100,
+        refreshSucceeded: 99,
+        lastRefreshHostName: "mysql-primary.example.com",
+      };
+      mockHttpsResponse(mockMetadata);
+
+      const tool = tools.find(
+        (t) => t.name === "mysql_router_metadata_status",
+      )!;
+      const result = await tool.handler(
+        { metadataName: "my_cluster" },
+        mockContext,
+      );
+
+      expect(mockRequest).toHaveBeenCalled();
+      const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
+      expect(options.path).toContain("/metadata/my_cluster/status");
+      expect(result).toEqual({
+        success: true,
+        metadataName: "my_cluster",
+        status: mockMetadata,
+      });
+    });
+  });
+
+  describe("mysql_router_pool_status", () => {
+    it("should fetch connection pool status", async () => {
+      const mockPoolStatus = {
+        idleServerConnections: 10,
+        stashedServerConnections: 5,
+      };
+      mockHttpsResponse(mockPoolStatus);
+
+      const tool = tools.find((t) => t.name === "mysql_router_pool_status")!;
+      const result = await tool.handler({ poolName: "default" }, mockContext);
+
+      expect(mockRequest).toHaveBeenCalled();
+      const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
+      expect(options.path).toContain("/connection_pool/default/status");
+      expect(result).toEqual({
+        success: true,
+        poolName: "default",
+        status: mockPoolStatus,
+      });
+    });
+  });
 });
 
-describe('HTTP Header Handling', () => {
-    let tools: ReturnType<typeof getRouterTools>;
-    let mockContext: ReturnType<typeof createMockRequestContext>;
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        tools = getRouterTools(createMockMySQLAdapter() as unknown as MySQLAdapter);
-        mockContext = createMockRequestContext();
-    });
-
-    it('should send Accept: application/json header', async () => {
-        const mockReq = new EventEmitter() as EventEmitter & { end: () => void; destroy: () => void };
-        mockReq.end = vi.fn();
-        mockReq.destroy = vi.fn();
-
-        mockRequest.mockImplementation((_options, callback) => {
-            const mockRes = new EventEmitter() as EventEmitter & { statusCode: number; statusMessage: string };
-            mockRes.statusCode = 200;
-            mockRes.statusMessage = 'OK';
+describe("HTTP Header Handling", () => {
+  let tools: ReturnType<typeof getRouterTools>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
 
-            setImmediate(() => {
-                callback?.(mockRes);
-                mockRes.emit('data', '{}');
-                mockRes.emit('end');
-            });
+  beforeEach(() => {
+    vi.clearAllMocks();
+    tools = getRouterTools(createMockMySQLAdapter() as unknown as MySQLAdapter);
+    mockContext = createMockRequestContext();
+  });
 
-            return mockReq;
-        });
-
-        const tool = tools.find(t => t.name === 'mysql_router_status')!;
-        await tool.handler({}, mockContext);
-
-        const options = mockRequest.mock.calls[0][0] as Record<string, Record<string, string>>;
-        expect(options.headers?.Accept).toBe('application/json');
-    });
+  it("should send Accept: application/json header", async () => {
+    const mockReq = new EventEmitter() as EventEmitter & {
+      end: () => void;
+      destroy: () => void;
+    };
+    mockReq.end = vi.fn();
+    mockReq.destroy = vi.fn();
+
+    mockRequest.mockImplementation((_options, callback) => {
+      const mockRes = new EventEmitter() as EventEmitter & {
+        statusCode: number;
+        statusMessage: string;
+      };
+      mockRes.statusCode = 200;
+      mockRes.statusMessage = "OK";
+
+      setImmediate(() => {
+        callback?.(mockRes);
+        mockRes.emit("data", "{}");
+        mockRes.emit("end");
+      });
+
+      return mockReq;
+    });
+
+    const tool = tools.find((t) => t.name === "mysql_router_status")!;
+    await tool.handler({}, mockContext);
+
+    const options = mockRequest.mock.calls[0][0] as Record<
+      string,
+      Record<string, string>
+    >;
+    expect(options.headers?.Accept).toBe("application/json");
+  });
 });
 
-describe('Error Handling', () => {
-    let tools: ReturnType<typeof getRouterTools>;
-    let mockContext: ReturnType<typeof createMockRequestContext>;
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        tools = getRouterTools(createMockMySQLAdapter() as unknown as MySQLAdapter);
-        mockContext = createMockRequestContext();
-    });
+describe("Error Handling", () => {
+  let tools: ReturnType<typeof getRouterTools>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
 
-    it('should throw on non-ok response', async () => {
-        const mockReq = new EventEmitter() as EventEmitter & { end: () => void; destroy: () => void };
-        mockReq.end = vi.fn();
-        mockReq.destroy = vi.fn();
+  beforeEach(() => {
+    vi.clearAllMocks();
+    tools = getRouterTools(createMockMySQLAdapter() as unknown as MySQLAdapter);
+    mockContext = createMockRequestContext();
+  });
 
-        mockRequest.mockImplementation((_options, callback) => {
-            const mockRes = new EventEmitter() as EventEmitter & { statusCode: number; statusMessage: string };
-            mockRes.statusCode = 401;
-            mockRes.statusMessage = 'Unauthorized';
-
-            setImmediate(() => {
-                callback?.(mockRes);
-                mockRes.emit('end');
-            });
-
-            return mockReq;
-        });
-
-        const tool = tools.find(t => t.name === 'mysql_router_status')!;
-
-        await expect(tool.handler({}, mockContext)).rejects.toThrow('Router API error: 401 Unauthorized');
-    });
-
-    it('should throw on 404 response', async () => {
-        const mockReq = new EventEmitter() as EventEmitter & { end: () => void; destroy: () => void };
-        mockReq.end = vi.fn();
-        mockReq.destroy = vi.fn();
-
-        mockRequest.mockImplementation((_options, callback) => {
-            const mockRes = new EventEmitter() as EventEmitter & { statusCode: number; statusMessage: string };
-            mockRes.statusCode = 404;
-            mockRes.statusMessage = 'Not Found';
-
-            setImmediate(() => {
-                callback?.(mockRes);
-                mockRes.emit('end');
-            });
+  it("should return unavailable response on 401 Unauthorized", async () => {
+    const mockReq = new EventEmitter() as EventEmitter & {
+      end: () => void;
+      destroy: () => void;
+    };
+    mockReq.end = vi.fn();
+    mockReq.destroy = vi.fn();
 
-            return mockReq;
-        });
+    mockRequest.mockImplementation((_options, callback) => {
+      const mockRes = new EventEmitter() as EventEmitter & {
+        statusCode: number;
+        statusMessage: string;
+      };
+      mockRes.statusCode = 401;
+      mockRes.statusMessage = "Unauthorized";
 
-        const tool = tools.find(t => t.name === 'mysql_router_route_status')!;
+      setImmediate(() => {
+        callback?.(mockRes);
+        mockRes.emit("end");
+      });
 
-        await expect(tool.handler({ routeName: 'nonexistent' }, mockContext)).rejects.toThrow('Router API error: 404 Not Found');
+      return mockReq;
     });
 
-    it('should throw on network error', async () => {
-        const mockReq = new EventEmitter() as EventEmitter & { end: () => void; destroy: () => void };
-        mockReq.end = vi.fn();
-        mockReq.destroy = vi.fn();
-
-        mockRequest.mockImplementation(() => {
-            setImmediate(() => {
-                mockReq.emit('error', new Error('Network error'));
-            });
-            return mockReq;
-        });
-
-        const tool = tools.find(t => t.name === 'mysql_router_status')!;
+    const tool = tools.find((t) => t.name === "mysql_router_status")!;
+    const result = await tool.handler({}, mockContext);
 
-        await expect(tool.handler({}, mockContext)).rejects.toThrow('Network error');
+    expect(result).toEqual({
+      available: false,
+      reason: "Router API error: 401 Unauthorized",
     });
+  });
 
-    it('should throw on connection refused', async () => {
-        const mockReq = new EventEmitter() as EventEmitter & { end: () => void; destroy: () => void };
-        mockReq.end = vi.fn();
-        mockReq.destroy = vi.fn();
+  it("should return unavailable response on 404 Not Found", async () => {
+    const mockReq = new EventEmitter() as EventEmitter & {
+      end: () => void;
+      destroy: () => void;
+    };
+    mockReq.end = vi.fn();
+    mockReq.destroy = vi.fn();
 
-        mockRequest.mockImplementation(() => {
-            setImmediate(() => {
-                mockReq.emit('error', new Error('ECONNREFUSED'));
-            });
-            return mockReq;
-        });
+    mockRequest.mockImplementation((_options, callback) => {
+      const mockRes = new EventEmitter() as EventEmitter & {
+        statusCode: number;
+        statusMessage: string;
+      };
+      mockRes.statusCode = 404;
+      mockRes.statusMessage = "Not Found";
 
-        const tool = tools.find(t => t.name === 'mysql_router_status')!;
+      setImmediate(() => {
+        callback?.(mockRes);
+        mockRes.emit("end");
+      });
 
-        await expect(tool.handler({}, mockContext)).rejects.toThrow('ECONNREFUSED');
+      return mockReq;
     });
-});
 
-describe('Authentication and TLS Handling', () => {
-    let originalEnv: NodeJS.ProcessEnv;
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        // Save original env
-        originalEnv = { ...process.env };
-        // Clear relevant env vars
-        delete process.env['MYSQL_ROUTER_URL'];
-        delete process.env['MYSQL_ROUTER_USER'];
-        delete process.env['MYSQL_ROUTER_PASSWORD'];
-        delete process.env['MYSQL_ROUTER_INSECURE'];
-        delete process.env['NODE_TLS_REJECT_UNAUTHORIZED'];
-    });
+    const tool = tools.find((t) => t.name === "mysql_router_route_status")!;
+    const result = await tool.handler(
+      { routeName: "nonexistent" },
+      mockContext,
+    );
 
-    afterEach(() => {
-        vi.restoreAllMocks();
-        // Restore original env
-        process.env = originalEnv;
+    expect(result).toEqual({
+      available: false,
+      reason: "Router API error: 404 Not Found",
     });
+  });
 
-    // Helper to mock response
-    const setupMockRequest = () => {
-        const mockReq = new EventEmitter() as EventEmitter & { end: () => void; destroy: () => void };
-        mockReq.end = vi.fn();
-        mockReq.destroy = vi.fn();
-
-        mockRequest.mockImplementation((_options, callback) => {
-            const mockRes = new EventEmitter() as EventEmitter & { statusCode: number; statusMessage: string };
-            mockRes.statusCode = 200;
-            mockRes.statusMessage = 'OK';
-
-            setImmediate(() => {
-                callback?.(mockRes);
-                mockRes.emit('data', '{}');
-                mockRes.emit('end');
-            });
-
-            return mockReq;
-        });
-
-        return mockReq;
+  it("should return unavailable response on network error", async () => {
+    const mockReq = new EventEmitter() as EventEmitter & {
+      end: () => void;
+      destroy: () => void;
     };
+    mockReq.end = vi.fn();
+    mockReq.destroy = vi.fn();
 
-    it('should add Basic auth header when credentials provided', async () => {
-        process.env['MYSQL_ROUTER_USER'] = 'admin';
-        process.env['MYSQL_ROUTER_PASSWORD'] = 'secret';
-
-        setupMockRequest();
-
-        const tools = getRouterTools(createMockMySQLAdapter() as unknown as MySQLAdapter);
-        const tool = tools.find(t => t.name === 'mysql_router_status')!;
-        await tool.handler({}, createMockRequestContext());
-
-        const options = mockRequest.mock.calls[0][0] as Record<string, Record<string, string>>;
-        expect(options.headers?.Authorization).toMatch(/^Basic /);
-        // Verify the encoded value
-        const expectedAuth = Buffer.from('admin:secret').toString('base64');
-        expect(options.headers?.Authorization).toBe(`Basic ${expectedAuth}`);
+    mockRequest.mockImplementation(() => {
+      setImmediate(() => {
+        mockReq.emit("error", new Error("Network error"));
+      });
+      return mockReq;
     });
 
-    it('should not add auth header when no credentials provided', async () => {
-        setupMockRequest();
-
-        const tools = getRouterTools(createMockMySQLAdapter() as unknown as MySQLAdapter);
-        const tool = tools.find(t => t.name === 'mysql_router_status')!;
-        await tool.handler({}, createMockRequestContext());
+    const tool = tools.find((t) => t.name === "mysql_router_status")!;
+    const result = await tool.handler({}, mockContext);
 
-        const options = mockRequest.mock.calls[0][0] as Record<string, Record<string, string>>;
-        expect(options.headers?.Authorization).toBeUndefined();
+    expect(result).toEqual({
+      available: false,
+      reason: "Router API request failed: Network error",
     });
+  });
 
-    it('should set rejectUnauthorized=false for HTTPS with insecure=true', async () => {
-        process.env['MYSQL_ROUTER_URL'] = 'https://localhost:8443';
-        process.env['MYSQL_ROUTER_INSECURE'] = 'true';
-
-        setupMockRequest();
-
-        const tools = getRouterTools(createMockMySQLAdapter() as unknown as MySQLAdapter);
-        const tool = tools.find(t => t.name === 'mysql_router_status')!;
-        await tool.handler({}, createMockRequestContext());
+  it("should return unavailable response on connection refused", async () => {
+    const mockReq = new EventEmitter() as EventEmitter & {
+      end: () => void;
+      destroy: () => void;
+    };
+    mockReq.end = vi.fn();
+    mockReq.destroy = vi.fn();
 
-        const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
-        // insecure=true means rejectUnauthorized should be false
-        expect(options.rejectUnauthorized).toBe(false);
+    mockRequest.mockImplementation(() => {
+      setImmediate(() => {
+        const error = new Error("ECONNREFUSED") as NodeJS.ErrnoException;
+        error.code = "ECONNREFUSED";
+        mockReq.emit("error", error);
+      });
+      return mockReq;
     });
 
-    it('should set rejectUnauthorized=true for secure HTTPS requests', async () => {
-        process.env['MYSQL_ROUTER_URL'] = 'https://localhost:8443';
-        process.env['MYSQL_ROUTER_INSECURE'] = 'false';
+    const tool = tools.find((t) => t.name === "mysql_router_status")!;
+    const result = await tool.handler({}, mockContext);
 
-        setupMockRequest();
-
-        const tools = getRouterTools(createMockMySQLAdapter() as unknown as MySQLAdapter);
-        const tool = tools.find(t => t.name === 'mysql_router_status')!;
-        await tool.handler({}, createMockRequestContext());
-
-        const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
-        // insecure=false means rejectUnauthorized should be true
-        expect(options.rejectUnauthorized).toBe(true);
+    expect(result).toEqual({
+      available: false,
+      reason: expect.stringContaining("Connection refused"),
     });
+  });
+});
 
-    it('should not modify NODE_TLS_REJECT_UNAUTHORIZED env var', async () => {
-        process.env['MYSQL_ROUTER_URL'] = 'https://localhost:8443';
-        process.env['MYSQL_ROUTER_INSECURE'] = 'true';
-        const originalValue = process.env['NODE_TLS_REJECT_UNAUTHORIZED'];
-
-        setupMockRequest();
-
-        const tools = getRouterTools(createMockMySQLAdapter() as unknown as MySQLAdapter);
-        const tool = tools.find(t => t.name === 'mysql_router_status')!;
-        await tool.handler({}, createMockRequestContext());
-
-        // New implementation should not modify this env var
-        expect(process.env['NODE_TLS_REJECT_UNAUTHORIZED']).toBe(originalValue);
-    });
+describe("Authentication and TLS Handling", () => {
+  let originalEnv: NodeJS.ProcessEnv;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Save original env
+    originalEnv = { ...process.env };
+    // Clear relevant env vars
+    delete process.env["MYSQL_ROUTER_URL"];
+    delete process.env["MYSQL_ROUTER_USER"];
+    delete process.env["MYSQL_ROUTER_PASSWORD"];
+    delete process.env["MYSQL_ROUTER_INSECURE"];
+    delete process.env["NODE_TLS_REJECT_UNAUTHORIZED"];
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    // Restore original env
+    process.env = originalEnv;
+  });
+
+  // Helper to mock response
+  const setupMockRequest = () => {
+    const mockReq = new EventEmitter() as EventEmitter & {
+      end: () => void;
+      destroy: () => void;
+    };
+    mockReq.end = vi.fn();
+    mockReq.destroy = vi.fn();
+
+    mockRequest.mockImplementation((_options, callback) => {
+      const mockRes = new EventEmitter() as EventEmitter & {
+        statusCode: number;
+        statusMessage: string;
+      };
+      mockRes.statusCode = 200;
+      mockRes.statusMessage = "OK";
+
+      setImmediate(() => {
+        callback?.(mockRes);
+        mockRes.emit("data", "{}");
+        mockRes.emit("end");
+      });
+
+      return mockReq;
+    });
+
+    return mockReq;
+  };
+
+  it("should add Basic auth header when credentials provided", async () => {
+    process.env["MYSQL_ROUTER_USER"] = "admin";
+    process.env["MYSQL_ROUTER_PASSWORD"] = "secret";
+
+    setupMockRequest();
+
+    const tools = getRouterTools(
+      createMockMySQLAdapter() as unknown as MySQLAdapter,
+    );
+    const tool = tools.find((t) => t.name === "mysql_router_status")!;
+    await tool.handler({}, createMockRequestContext());
+
+    const options = mockRequest.mock.calls[0][0] as Record<
+      string,
+      Record<string, string>
+    >;
+    expect(options.headers?.Authorization).toMatch(/^Basic /);
+    // Verify the encoded value
+    const expectedAuth = Buffer.from("admin:secret").toString("base64");
+    expect(options.headers?.Authorization).toBe(`Basic ${expectedAuth}`);
+  });
+
+  it("should not add auth header when no credentials provided", async () => {
+    setupMockRequest();
+
+    const tools = getRouterTools(
+      createMockMySQLAdapter() as unknown as MySQLAdapter,
+    );
+    const tool = tools.find((t) => t.name === "mysql_router_status")!;
+    await tool.handler({}, createMockRequestContext());
+
+    const options = mockRequest.mock.calls[0][0] as Record<
+      string,
+      Record<string, string>
+    >;
+    expect(options.headers?.Authorization).toBeUndefined();
+  });
+
+  it("should set rejectUnauthorized=false for HTTPS with insecure=true", async () => {
+    process.env["MYSQL_ROUTER_URL"] = "https://localhost:8443";
+    process.env["MYSQL_ROUTER_INSECURE"] = "true";
+
+    setupMockRequest();
+
+    const tools = getRouterTools(
+      createMockMySQLAdapter() as unknown as MySQLAdapter,
+    );
+    const tool = tools.find((t) => t.name === "mysql_router_status")!;
+    await tool.handler({}, createMockRequestContext());
+
+    const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
+    // insecure=true means rejectUnauthorized should be false
+    expect(options.rejectUnauthorized).toBe(false);
+  });
+
+  it("should set rejectUnauthorized=true for secure HTTPS requests", async () => {
+    process.env["MYSQL_ROUTER_URL"] = "https://localhost:8443";
+    process.env["MYSQL_ROUTER_INSECURE"] = "false";
+
+    setupMockRequest();
+
+    const tools = getRouterTools(
+      createMockMySQLAdapter() as unknown as MySQLAdapter,
+    );
+    const tool = tools.find((t) => t.name === "mysql_router_status")!;
+    await tool.handler({}, createMockRequestContext());
+
+    const options = mockRequest.mock.calls[0][0] as Record<string, unknown>;
+    // insecure=false means rejectUnauthorized should be true
+    expect(options.rejectUnauthorized).toBe(true);
+  });
+
+  it("should not modify NODE_TLS_REJECT_UNAUTHORIZED env var", async () => {
+    process.env["MYSQL_ROUTER_URL"] = "https://localhost:8443";
+    process.env["MYSQL_ROUTER_INSECURE"] = "true";
+    const originalValue = process.env["NODE_TLS_REJECT_UNAUTHORIZED"];
+
+    setupMockRequest();
+
+    const tools = getRouterTools(
+      createMockMySQLAdapter() as unknown as MySQLAdapter,
+    );
+    const tool = tools.find((t) => t.name === "mysql_router_status")!;
+    await tool.handler({}, createMockRequestContext());
+
+    // New implementation should not modify this env var
+    expect(process.env["NODE_TLS_REJECT_UNAUTHORIZED"]).toBe(originalValue);
+  });
 });