@neverinfamous/mysql-mcp 2.1.0

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

@@ -0,0 +1,603 @@
+/**
+ * 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';
+
+// Mock https module
+vi.mock('node:https', () => ({
+    default: {
+        request: vi.fn()
+    }
+}));
+
+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);
+    });
+
+    it('should return 9 router tools', () => {
+        expect(tools).toHaveLength(9);
+    });
+
+    it('should have router group for all tools', () => {
+        for (const tool of tools) {
+            expect(tool.group).toBe('router');
+        }
+    });
+
+    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 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);
+        }
+    });
+
+    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 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('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
+            });
+        });
+    });
+});
+
+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';
+
+            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();
+    });
+
+    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();
+
+        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');
+            });
+
+            return mockReq;
+        });
+
+        const tool = tools.find(t => t.name === 'mysql_router_route_status')!;
+
+        await expect(tool.handler({ routeName: 'nonexistent' }, mockContext)).rejects.toThrow('Router API error: 404 Not Found');
+    });
+
+    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')!;
+
+        await expect(tool.handler({}, mockContext)).rejects.toThrow('Network error');
+    });
+
+    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();
+
+        mockRequest.mockImplementation(() => {
+            setImmediate(() => {
+                mockReq.emit('error', new Error('ECONNREFUSED'));
+            });
+            return mockReq;
+        });
+
+        const tool = tools.find(t => t.name === 'mysql_router_status')!;
+
+        await expect(tool.handler({}, mockContext)).rejects.toThrow('ECONNREFUSED');
+    });
+});
+
+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);
+    });
+});