@neverinfamous/mysql-mcp 2.1.0 → 2.3.0

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

@@ -1,349 +1,457 @@
 /**
  * mysql-mcp - Cluster Tools Unit Tests
- * 
+ *
  * Tests for cluster tool definitions, annotations, and handler execution.
  */
 
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { getClusterTools } from '../cluster/index.js';
-import type { MySQLAdapter } from '../../MySQLAdapter.js';
-import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../__tests__/mocks/index.js';
-
-describe('getClusterTools', () => {
-    let tools: ReturnType<typeof getClusterTools>;
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { getClusterTools } from "../cluster/index.js";
+import type { MySQLAdapter } from "../../MySQLAdapter.js";
+import {
+  createMockMySQLAdapter,
+  createMockRequestContext,
+  createMockQueryResult,
+} from "../../../../__tests__/mocks/index.js";
+
+describe("getClusterTools", () => {
+  let tools: ReturnType<typeof getClusterTools>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    tools = getClusterTools(
+      createMockMySQLAdapter() as unknown as MySQLAdapter,
+    );
+  });
+
+  it("should return 10 cluster tools", () => {
+    expect(tools).toHaveLength(10);
+  });
+
+  it("should have cluster group for all tools", () => {
+    for (const tool of tools) {
+      expect(tool.group).toBe("cluster");
+    }
+  });
+
+  it("should have handler functions for all tools", () => {
+    for (const tool of tools) {
+      expect(typeof tool.handler).toBe("function");
+    }
+  });
+
+  it("should have inputSchema for all tools", () => {
+    for (const tool of tools) {
+      expect(tool.inputSchema).toBeDefined();
+    }
+  });
+
+  it("should include expected tool names", () => {
+    const names = tools.map((t) => t.name);
+    expect(names).toContain("mysql_gr_status");
+    expect(names).toContain("mysql_gr_members");
+    expect(names).toContain("mysql_gr_primary");
+    expect(names).toContain("mysql_gr_transactions");
+    expect(names).toContain("mysql_gr_flow_control");
+    expect(names).toContain("mysql_cluster_status");
+    expect(names).toContain("mysql_cluster_instances");
+    expect(names).toContain("mysql_cluster_topology");
+    expect(names).toContain("mysql_cluster_router_status");
+    expect(names).toContain("mysql_cluster_switchover");
+  });
+});
 
-    beforeEach(() => {
-        vi.clearAllMocks();
-        tools = getClusterTools(createMockMySQLAdapter() as unknown as MySQLAdapter);
+describe("Handler Execution", () => {
+  let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+  let tools: ReturnType<typeof getClusterTools>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockAdapter = createMockMySQLAdapter();
+    tools = getClusterTools(mockAdapter as unknown as MySQLAdapter);
+    mockContext = createMockRequestContext();
+  });
+
+  describe("mysql_gr_status", () => {
+    it("should query group_replication status", async () => {
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(
+          createMockQueryResult([{ PLUGIN_STATUS: "ACTIVE" }]),
+        ) // Plugin check
+        .mockResolvedValueOnce(
+          createMockQueryResult([{ MEMBER_STATE: "ONLINE" }]),
+        );
+
+      const tool = tools.find((t) => t.name === "mysql_gr_status")!;
+      const result = await tool.handler({}, mockContext);
+
+      expect(mockAdapter.executeQuery).toHaveBeenCalled();
+      // Returns enabled, groupName, members etc
+      expect(result).toHaveProperty("enabled");
+      expect(result).toHaveProperty("members");
     });
-
-    it('should return 10 cluster tools', () => {
-        expect(tools).toHaveLength(10);
+  });
+
+  describe("mysql_gr_members", () => {
+    it("should list group replication members", async () => {
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(
+          createMockQueryResult([{ PLUGIN_STATUS: "ACTIVE" }]),
+        ) // Plugin check
+        .mockResolvedValueOnce(
+          createMockQueryResult([
+            { memberId: "uuid1", host: "node1", state: "ONLINE" },
+            { memberId: "uuid2", host: "node2", state: "ONLINE" },
+          ]),
+        );
+
+      const tool = tools.find((t) => t.name === "mysql_gr_members")!;
+      const result = await tool.handler({}, mockContext);
+
+      expect(mockAdapter.executeQuery).toHaveBeenCalled();
+      const call = mockAdapter.executeQuery.mock.calls[1][0] as string; // Second call is the query
+      expect(call).toContain("replication_group_members");
+      expect(result).toHaveProperty("members");
+      expect(result).toHaveProperty("count");
     });
 
-    it('should have cluster group for all tools', () => {
-        for (const tool of tools) {
-            expect(tool.group).toBe('cluster');
-        }
+    it("should accept memberId parameter", async () => {
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(
+          createMockQueryResult([{ PLUGIN_STATUS: "ACTIVE" }]),
+        ) // Plugin check
+        .mockResolvedValueOnce(createMockQueryResult([]));
+
+      const tool = tools.find((t) => t.name === "mysql_gr_members")!;
+      await tool.handler({ memberId: "uuid1" }, mockContext);
+
+      // Plugin check is first call
+      expect(mockAdapter.executeQuery).toHaveBeenNthCalledWith(
+        1,
+        expect.stringContaining(
+          "SELECT PLUGIN_STATUS FROM information_schema.PLUGINS",
+        ),
+      );
+
+      // Uses parameterized query with ?
+      expect(mockAdapter.executeQuery).toHaveBeenNthCalledWith(
+        2,
+        expect.stringContaining("WHERE m.MEMBER_ID = ?"),
+        ["uuid1"],
+      );
     });
-
-    it('should have handler functions for all tools', () => {
-        for (const tool of tools) {
-            expect(typeof tool.handler).toBe('function');
-        }
+  });
+
+  describe("mysql_gr_primary", () => {
+    it("should get primary member info", async () => {
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(
+          createMockQueryResult([{ PLUGIN_STATUS: "ACTIVE" }]),
+        ) // Plugin check
+        .mockResolvedValueOnce(
+          createMockQueryResult([{ memberId: "uuid1", host: "primary.local" }]),
+        );
+
+      const tool = tools.find((t) => t.name === "mysql_gr_primary")!;
+      const result = await tool.handler({}, mockContext);
+
+      expect(mockAdapter.executeQuery).toHaveBeenCalled();
+      expect(result).toHaveProperty("primary");
+      expect(result).toHaveProperty("hasPrimary");
     });
-
-    it('should have inputSchema for all tools', () => {
-        for (const tool of tools) {
-            expect(tool.inputSchema).toBeDefined();
-        }
+  });
+
+  describe("mysql_gr_transactions", () => {
+    it("should get transaction status", async () => {
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(
+          createMockQueryResult([{ PLUGIN_STATUS: "ACTIVE" }]),
+        ) // Plugin check
+        .mockResolvedValueOnce(
+          createMockQueryResult([
+            { memberId: "uuid1", txInQueue: 0, txChecked: 100 },
+          ]),
+        );
+
+      const tool = tools.find((t) => t.name === "mysql_gr_transactions")!;
+      const result = await tool.handler({}, mockContext);
+
+      expect(mockAdapter.executeQuery).toHaveBeenCalled();
+      expect(result).toHaveProperty("memberStats");
+      expect(result).toHaveProperty("gtid");
     });
-
-    it('should include expected tool names', () => {
-        const names = tools.map(t => t.name);
-        expect(names).toContain('mysql_gr_status');
-        expect(names).toContain('mysql_gr_members');
-        expect(names).toContain('mysql_gr_primary');
-        expect(names).toContain('mysql_gr_transactions');
-        expect(names).toContain('mysql_gr_flow_control');
-        expect(names).toContain('mysql_cluster_status');
-        expect(names).toContain('mysql_cluster_instances');
-        expect(names).toContain('mysql_cluster_topology');
-        expect(names).toContain('mysql_cluster_router_status');
-        expect(names).toContain('mysql_cluster_switchover');
+  });
+
+  describe("mysql_gr_flow_control", () => {
+    it("should get flow control statistics", async () => {
+      mockAdapter.executeQuery
+        .mockResolvedValueOnce(
+          createMockQueryResult([{ PLUGIN_STATUS: "ACTIVE" }]),
+        ) // Plugin check
+        .mockResolvedValueOnce(
+          createMockQueryResult([
+            { flowControlMode: "QUOTA", certifierThreshold: 25000 },
+          ]),
+        );
+
+      const tool = tools.find((t) => t.name === "mysql_gr_flow_control")!;
+      const result = await tool.handler({}, mockContext);
+
+      expect(mockAdapter.executeQuery).toHaveBeenCalled();
+      expect(result).toHaveProperty("configuration");
+      expect(result).toHaveProperty("memberQueues");
+      expect(result).toHaveProperty("isThrottling");
     });
-});
+  });
 
-describe('Handler Execution', () => {
-    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
-    let tools: ReturnType<typeof getClusterTools>;
-    let mockContext: ReturnType<typeof createMockRequestContext>;
+  describe("mysql_cluster_status", () => {
+    it("should get cluster status", async () => {
+      mockAdapter.executeQuery.mockResolvedValue(
+        createMockQueryResult([{ cluster_name: "myCluster", status: "OK" }]),
+      );
 
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockAdapter = createMockMySQLAdapter();
-        tools = getClusterTools(mockAdapter as unknown as MySQLAdapter);
-        mockContext = createMockRequestContext();
-    });
+      const tool = tools.find((t) => t.name === "mysql_cluster_status")!;
+      const result = await tool.handler({}, mockContext);
 
-    describe('mysql_gr_status', () => {
-        it('should query group_replication status', async () => {
-            mockAdapter.executeQuery
-                .mockResolvedValueOnce(createMockQueryResult([{ PLUGIN_STATUS: 'ACTIVE' }])) // Plugin check
-                .mockResolvedValueOnce(
-                    createMockQueryResult([{ MEMBER_STATE: 'ONLINE' }])
-                );
-
-            const tool = tools.find(t => t.name === 'mysql_gr_status')!;
-            const result = await tool.handler({}, mockContext);
-
-            expect(mockAdapter.executeQuery).toHaveBeenCalled();
-            // Returns enabled, groupName, members etc
-            expect(result).toHaveProperty('enabled');
-            expect(result).toHaveProperty('members');
-        });
+      expect(mockAdapter.executeQuery).toHaveBeenCalled();
+      // Returns isInnoDBCluster, cluster, etc
+      expect(result).toBeDefined();
     });
+  });
 
-    describe('mysql_gr_members', () => {
-        it('should list group replication members', async () => {
-            mockAdapter.executeQuery
-                .mockResolvedValueOnce(createMockQueryResult([{ PLUGIN_STATUS: 'ACTIVE' }])) // Plugin check
-                .mockResolvedValueOnce(
-                    createMockQueryResult([
-                        { memberId: 'uuid1', host: 'node1', state: 'ONLINE' },
-                        { memberId: 'uuid2', host: 'node2', state: 'ONLINE' }
-                    ])
-                );
-
-            const tool = tools.find(t => t.name === 'mysql_gr_members')!;
-            const result = await tool.handler({}, mockContext);
-
-            expect(mockAdapter.executeQuery).toHaveBeenCalled();
-            const call = mockAdapter.executeQuery.mock.calls[1][0] as string; // Second call is the query
-            expect(call).toContain('replication_group_members');
-            expect(result).toHaveProperty('members');
-            expect(result).toHaveProperty('count');
-        });
-
-        it('should accept memberId parameter', async () => {
-            mockAdapter.executeQuery
-                .mockResolvedValueOnce(createMockQueryResult([{ PLUGIN_STATUS: 'ACTIVE' }])) // Plugin check
-                .mockResolvedValueOnce(createMockQueryResult([]));
-
-            const tool = tools.find(t => t.name === 'mysql_gr_members')!;
-            await tool.handler({ memberId: 'uuid1' }, mockContext);
-
-            // Plugin check is first call
-            expect(mockAdapter.executeQuery).toHaveBeenNthCalledWith(1,
-                expect.stringContaining('SELECT PLUGIN_STATUS FROM information_schema.PLUGINS')
-            );
-
-            // Uses parameterized query with ?
-            expect(mockAdapter.executeQuery).toHaveBeenNthCalledWith(2,
-                expect.stringContaining('WHERE m.MEMBER_ID = ?'),
-                ['uuid1']
-            );
-        });
-    });
+  describe("mysql_cluster_instances", () => {
+    it("should list cluster instances", async () => {
+      mockAdapter.executeQuery.mockResolvedValue(
+        createMockQueryResult([
+          { instance_name: "mysql-1", address: "mysql-1:3306" },
+        ]),
+      );
 
-    describe('mysql_gr_primary', () => {
-        it('should get primary member info', async () => {
-            mockAdapter.executeQuery
-                .mockResolvedValueOnce(createMockQueryResult([{ PLUGIN_STATUS: 'ACTIVE' }])) // Plugin check
-                .mockResolvedValueOnce(
-                    createMockQueryResult([{ memberId: 'uuid1', host: 'primary.local' }])
-                );
-
-            const tool = tools.find(t => t.name === 'mysql_gr_primary')!;
-            const result = await tool.handler({}, mockContext);
-
-            expect(mockAdapter.executeQuery).toHaveBeenCalled();
-            expect(result).toHaveProperty('primary');
-            expect(result).toHaveProperty('hasPrimary');
-        });
-    });
+      const tool = tools.find((t) => t.name === "mysql_cluster_instances")!;
+      const result = await tool.handler({}, mockContext);
 
-    describe('mysql_gr_transactions', () => {
-        it('should get transaction status', async () => {
-            mockAdapter.executeQuery
-                .mockResolvedValueOnce(createMockQueryResult([{ PLUGIN_STATUS: 'ACTIVE' }])) // Plugin check
-                .mockResolvedValueOnce(createMockQueryResult([
-                    { memberId: 'uuid1', txInQueue: 0, txChecked: 100 }
-                ]));
-
-            const tool = tools.find(t => t.name === 'mysql_gr_transactions')!;
-            const result = await tool.handler({}, mockContext);
-
-            expect(mockAdapter.executeQuery).toHaveBeenCalled();
-            expect(result).toHaveProperty('memberStats');
-            expect(result).toHaveProperty('gtid');
-        });
+      expect(mockAdapter.executeQuery).toHaveBeenCalled();
+      expect(result).toHaveProperty("instances");
     });
 
-    describe('mysql_gr_flow_control', () => {
-        it('should get flow control statistics', async () => {
-            mockAdapter.executeQuery
-                .mockResolvedValueOnce(createMockQueryResult([{ PLUGIN_STATUS: 'ACTIVE' }])) // Plugin check
-                .mockResolvedValueOnce(createMockQueryResult([
-                    { flowControlMode: 'QUOTA', certifierThreshold: 25000 }
-                ]));
-
-            const tool = tools.find(t => t.name === 'mysql_gr_flow_control')!;
-            const result = await tool.handler({}, mockContext);
-
-            expect(mockAdapter.executeQuery).toHaveBeenCalled();
-            expect(result).toHaveProperty('configuration');
-            expect(result).toHaveProperty('memberQueues');
-            expect(result).toHaveProperty('isThrottling');
-        });
+    it("should fallback to GR members if metadata query fails", async () => {
+      // First query (metadata) fails
+      mockAdapter.executeQuery.mockRejectedValueOnce(
+        new Error("Table not found"),
+      );
+
+      // Second query (GR members) succeeds
+      mockAdapter.executeQuery.mockResolvedValueOnce(
+        createMockQueryResult([
+          { serverUuid: "uuid1", address: "node1:3306", memberState: "ONLINE" },
+        ]),
+      );
+
+      const tool = tools.find((t) => t.name === "mysql_cluster_instances")!;
+      const result = await tool.handler({}, mockContext);
+
+      expect(result).toHaveProperty("source", "group_replication");
+      expect(result).toHaveProperty("instances");
+      // Two calls: 1. metadata query, 2. fallback query
+      expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(2);
     });
-
-    describe('mysql_cluster_status', () => {
-        it('should get cluster status', async () => {
-            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
-                { cluster_name: 'myCluster', status: 'OK' }
-            ]));
-
-            const tool = tools.find(t => t.name === 'mysql_cluster_status')!;
-            const result = await tool.handler({}, mockContext);
-
-            expect(mockAdapter.executeQuery).toHaveBeenCalled();
-            // Returns isInnoDBCluster, cluster, etc
-            expect(result).toBeDefined();
-        });
+  });
+
+  describe("mysql_cluster_topology", () => {
+    it("should get cluster topology", async () => {
+      mockAdapter.executeQuery.mockResolvedValue(
+        createMockQueryResult([
+          { id: "uuid1", host: "node1", role: "PRIMARY", state: "ONLINE" },
+        ]),
+      );
+
+      const tool = tools.find((t) => t.name === "mysql_cluster_topology")!;
+      const result = await tool.handler({}, mockContext);
+
+      expect(mockAdapter.executeQuery).toHaveBeenCalled();
+      expect(result).toHaveProperty("topology");
+      expect(result).toHaveProperty("visualization");
     });
 
-    describe('mysql_cluster_instances', () => {
-        it('should list cluster instances', async () => {
-            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
-                { instance_name: 'mysql-1', address: 'mysql-1:3306' }
-            ]));
+    it("should visualize all member states correctly", async () => {
+      mockAdapter.executeQuery.mockResolvedValue(
+        createMockQueryResult([
+          {
+            id: "uuid1",
+            host: "node1",
+            role: "PRIMARY",
+            state: "ONLINE",
+            port: 3306,
+          },
+          {
+            id: "uuid2",
+            host: "node2",
+            role: "SECONDARY",
+            state: "ONLINE",
+            port: 3306,
+          },
+          {
+            id: "uuid3",
+            host: "node3",
+            role: "SECONDARY",
+            state: "RECOVERING",
+            port: 3306,
+          },
+          {
+            id: "uuid4",
+            host: "node4",
+            role: "SECONDARY",
+            state: "OFFLINE",
+            port: 3306,
+          },
+        ]),
+      );
+
+      const tool = tools.find((t) => t.name === "mysql_cluster_topology")!;
+      const result: any = await tool.handler({}, mockContext);
+      const viz = result.visualization;
+
+      expect(viz).toContain("PRIMARY:");
+      expect(viz).toContain("SECONDARY:");
+      expect(viz).toContain("RECOVERING:");
+      expect(viz).toContain("OFFLINE/ERROR:");
+      expect(viz).toContain("★ node1:3306 (ONLINE)");
+      expect(viz).toContain("○ node2:3306 (ONLINE)");
+      expect(viz).toContain("⟳ node3:3306");
+      expect(viz).toContain("✗ node4:3306 (OFFLINE)");
+    });
+  });
 
-            const tool = tools.find(t => t.name === 'mysql_cluster_instances')!;
-            const result = await tool.handler({}, mockContext);
+  describe("mysql_cluster_router_status", () => {
+    it("should get router status from cluster perspective", async () => {
+      mockAdapter.executeQuery.mockResolvedValue(
+        createMockQueryResult([
+          { routerName: "router1", lastCheckIn: "2024-01-01" },
+        ]),
+      );
 
-            expect(mockAdapter.executeQuery).toHaveBeenCalled();
-            expect(result).toHaveProperty('instances');
-        });
+      const tool = tools.find((t) => t.name === "mysql_cluster_router_status")!;
+      const result = await tool.handler({}, mockContext);
 
-        it('should fallback to GR members if metadata query fails', async () => {
-            // First query (metadata) fails
-            mockAdapter.executeQuery.mockRejectedValueOnce(new Error('Table not found'));
+      expect(mockAdapter.executeQuery).toHaveBeenCalled();
+      expect(result).toBeDefined();
+    });
 
-            // Second query (GR members) succeeds
-            mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-                { serverUuid: 'uuid1', address: 'node1:3306', memberState: 'ONLINE' }
-            ]));
+    it("should handle error when router metadata is missing", async () => {
+      mockAdapter.executeQuery.mockRejectedValue(new Error("Table not found"));
 
-            const tool = tools.find(t => t.name === 'mysql_cluster_instances')!;
-            const result = await tool.handler({}, mockContext);
+      const tool = tools.find((t) => t.name === "mysql_cluster_router_status")!;
+      const result: any = await tool.handler({}, mockContext);
 
-            expect(result).toHaveProperty('source', 'group_replication');
-            expect(result).toHaveProperty('instances');
-            // Two calls: 1. metadata query, 2. fallback query
-            expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(2);
-        });
+      expect(result.available).toBe(false);
+      expect(result.message).toContain("Router metadata not available");
+      expect(result.suggestion).toBeDefined();
     });
-
-    describe('mysql_cluster_topology', () => {
-        it('should get cluster topology', async () => {
-            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
-                { id: 'uuid1', host: 'node1', role: 'PRIMARY', state: 'ONLINE' }
-            ]));
-
-            const tool = tools.find(t => t.name === 'mysql_cluster_topology')!;
-            const result = await tool.handler({}, mockContext);
-
-            expect(mockAdapter.executeQuery).toHaveBeenCalled();
-            expect(result).toHaveProperty('topology');
-            expect(result).toHaveProperty('visualization');
-        });
-
-        it('should visualize all member states correctly', async () => {
-            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
-                { id: 'uuid1', host: 'node1', role: 'PRIMARY', state: 'ONLINE', port: 3306 },
-                { id: 'uuid2', host: 'node2', role: 'SECONDARY', state: 'ONLINE', port: 3306 },
-                { id: 'uuid3', host: 'node3', role: 'SECONDARY', state: 'RECOVERING', port: 3306 },
-                { id: 'uuid4', host: 'node4', role: 'SECONDARY', state: 'OFFLINE', port: 3306 }
-            ]));
-
-            const tool = tools.find(t => t.name === 'mysql_cluster_topology')!;
-            const result: any = await tool.handler({}, mockContext);
-            const viz = result.visualization;
-
-            expect(viz).toContain('PRIMARY:');
-            expect(viz).toContain('SECONDARY:');
-            expect(viz).toContain('RECOVERING:');
-            expect(viz).toContain('OFFLINE/ERROR:');
-            expect(viz).toContain('★ node1:3306 (ONLINE)');
-            expect(viz).toContain('○ node2:3306 (ONLINE)');
-            expect(viz).toContain('⟳ node3:3306');
-            expect(viz).toContain('✗ node4:3306 (OFFLINE)');
-        });
+  });
+
+  describe("mysql_cluster_switchover", () => {
+    it("should get switchover recommendation", async () => {
+      mockAdapter.executeQuery.mockResolvedValue(
+        createMockQueryResult([
+          {
+            memberId: "uuid1",
+            host: "node1",
+            role: "SECONDARY",
+            state: "ONLINE",
+          },
+        ]),
+      );
+
+      const tool = tools.find((t) => t.name === "mysql_cluster_switchover")!;
+      const result = await tool.handler({}, mockContext);
+
+      expect(mockAdapter.executeQuery).toHaveBeenCalled();
+      expect(result).toHaveProperty("candidates");
+      expect(result).toHaveProperty("canSwitchover");
     });
 
-    describe('mysql_cluster_router_status', () => {
-        it('should get router status from cluster perspective', async () => {
-            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
-                { routerName: 'router1', lastCheckIn: '2024-01-01' }
-            ]));
-
-            const tool = tools.find(t => t.name === 'mysql_cluster_router_status')!;
-            const result = await tool.handler({}, mockContext);
-
-            expect(mockAdapter.executeQuery).toHaveBeenCalled();
-            expect(result).toBeDefined();
-        });
-
-        it('should handle error when router metadata is missing', async () => {
-            mockAdapter.executeQuery.mockRejectedValue(new Error('Table not found'));
-
-            const tool = tools.find(t => t.name === 'mysql_cluster_router_status')!;
-            const result: any = await tool.handler({}, mockContext);
-
-            expect(result.available).toBe(false);
-            expect(result.message).toContain('Router metadata not available');
-            expect(result.suggestion).toBeDefined();
-        });
+    it("should categorize candidates by lag suitability", async () => {
+      // Mock members with different queue sizes
+      // uuid1: 0 queue (GOOD)
+      // uuid2: 50 queue (ACCEPTABLE)
+      // uuid3: 200 queue (NOT_RECOMMENDED)
+      mockAdapter.executeQuery.mockResolvedValue(
+        createMockQueryResult([
+          {
+            memberId: "uuid1",
+            host: "node1",
+            role: "SECONDARY",
+            state: "ONLINE",
+            txQueue: 0,
+            applierQueue: 0,
+          },
+          {
+            memberId: "uuid2",
+            host: "node2",
+            role: "SECONDARY",
+            state: "ONLINE",
+            txQueue: 20,
+            applierQueue: 30,
+          },
+          {
+            memberId: "uuid3",
+            host: "node3",
+            role: "SECONDARY",
+            state: "ONLINE",
+            txQueue: 150,
+            applierQueue: 50,
+          },
+          {
+            memberId: "uuid4",
+            host: "node4",
+            role: "PRIMARY",
+            state: "ONLINE",
+            txQueue: 0,
+            applierQueue: 0,
+          }, // Should be ignored
+        ]),
+      );
+
+      const tool = tools.find((t) => t.name === "mysql_cluster_switchover")!;
+      const result: any = await tool.handler({}, mockContext);
+      const candidates = result.candidates;
+
+      // Should filter out PRIMARY, so 3 candidates
+      expect(candidates).toHaveLength(3);
+
+      // Sort order check: GOOD -> ACCEPTABLE -> NOT_RECOMMENDED
+      expect(candidates[0].memberId).toBe("uuid1");
+      expect(candidates[0].suitability).toBe("GOOD");
+
+      expect(candidates[1].memberId).toBe("uuid2");
+      expect(candidates[1].suitability).toBe("ACCEPTABLE");
+
+      expect(candidates[2].memberId).toBe("uuid3");
+      expect(candidates[2].suitability).toBe("NOT_RECOMMENDED");
+
+      expect(result.recommendedTarget.memberId).toBe("uuid1");
+      expect(result.canSwitchover).toBe(true);
     });
 
-    describe('mysql_cluster_switchover', () => {
-        it('should get switchover recommendation', async () => {
-            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
-                { memberId: 'uuid1', host: 'node1', role: 'SECONDARY', state: 'ONLINE' }
-            ]));
-
-            const tool = tools.find(t => t.name === 'mysql_cluster_switchover')!;
-            const result = await tool.handler({}, mockContext);
-
-            expect(mockAdapter.executeQuery).toHaveBeenCalled();
-            expect(result).toHaveProperty('candidates');
-            expect(result).toHaveProperty('canSwitchover');
-        });
-
-        it('should categorize candidates by lag suitability', async () => {
-            // Mock members with different queue sizes
-            // uuid1: 0 queue (GOOD)
-            // uuid2: 50 queue (ACCEPTABLE)
-            // uuid3: 200 queue (NOT_RECOMMENDED)
-            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
-                { memberId: 'uuid1', host: 'node1', role: 'SECONDARY', state: 'ONLINE', txQueue: 0, applierQueue: 0 },
-                { memberId: 'uuid2', host: 'node2', role: 'SECONDARY', state: 'ONLINE', txQueue: 20, applierQueue: 30 },
-                { memberId: 'uuid3', host: 'node3', role: 'SECONDARY', state: 'ONLINE', txQueue: 150, applierQueue: 50 },
-                { memberId: 'uuid4', host: 'node4', role: 'PRIMARY', state: 'ONLINE', txQueue: 0, applierQueue: 0 } // Should be ignored
-            ]));
-
-            const tool = tools.find(t => t.name === 'mysql_cluster_switchover')!;
-            const result: any = await tool.handler({}, mockContext);
-            const candidates = result.candidates;
-
-            // Should filter out PRIMARY, so 3 candidates
-            expect(candidates).toHaveLength(3);
-
-            // Sort order check: GOOD -> ACCEPTABLE -> NOT_RECOMMENDED
-            expect(candidates[0].memberId).toBe('uuid1');
-            expect(candidates[0].suitability).toBe('GOOD');
-
-            expect(candidates[1].memberId).toBe('uuid2');
-            expect(candidates[1].suitability).toBe('ACCEPTABLE');
-
-            expect(candidates[2].memberId).toBe('uuid3');
-            expect(candidates[2].suitability).toBe('NOT_RECOMMENDED');
-
-            expect(result.recommendedTarget.memberId).toBe('uuid1');
-            expect(result.canSwitchover).toBe(true);
-        });
-
-        it('should warn if all candidates are not recommended', async () => {
-            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
-                { memberId: 'uuid1', host: 'node1', role: 'SECONDARY', state: 'ONLINE', txQueue: 200, applierQueue: 0 }
-            ]));
-
-            const tool = tools.find(t => t.name === 'mysql_cluster_switchover')!;
-            const result: any = await tool.handler({}, mockContext);
-
-            expect(result.recommendedTarget).toBeNull();
-            expect(result.warning).toBeDefined();
-        });
+    it("should warn if all candidates are not recommended", async () => {
+      mockAdapter.executeQuery.mockResolvedValue(
+        createMockQueryResult([
+          {
+            memberId: "uuid1",
+            host: "node1",
+            role: "SECONDARY",
+            state: "ONLINE",
+            txQueue: 200,
+            applierQueue: 0,
+          },
+        ]),
+      );
+
+      const tool = tools.find((t) => t.name === "mysql_cluster_switchover")!;
+      const result: any = await tool.handler({}, mockContext);
+
+      expect(result.recommendedTarget).toBeNull();
+      expect(result.warning).toBeDefined();
     });
+  });
 });