@neverinfamous/mysql-mcp 2.1.0

package/src/cli/__tests__/args.test.ts

@@ -0,0 +1,223 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { parseArgs } from '../args.js';
+
+// Mock process.exit
+vi.spyOn(process, 'exit').mockImplementation((code?: number | string | null | undefined) => {
+    throw new Error(`process.exit(${code})`);
+});
+
+// Mock console.error
+const mockConsoleError = vi.spyOn(console, 'error').mockImplementation(() => { });
+
+describe('CLI Args', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.unstubAllEnvs();
+
+        delete process.env['MYSQL_HOST'];
+        delete process.env['MYSQL_USER'];
+        delete process.env['MYSQL_PASSWORD'];
+        delete process.env['MYSQL_DATABASE'];
+        delete process.env['MYSQL_MCP_TOOL_FILTER'];
+        delete process.env['OAUTH_ENABLED'];
+    });
+
+    describe('parseArgs', () => {
+        it('should parse mysql connection string flag', () => {
+            const result = parseArgs(['--mysql', 'mysql://user:pass@host:3306/db']);
+            expect(result.databases).toHaveLength(1);
+            expect(result.databases[0]).toMatchObject({
+                host: 'host',
+                username: 'user',
+                password: 'pass',
+                database: 'db',
+                port: 3306
+            });
+        });
+
+        it('should parse individual mysql flags', () => {
+            const result = parseArgs([
+                '--mysql-host', 'localhost',
+                '--mysql-user', 'root',
+                '--mysql-password', 'secret',
+                '--mysql-database', 'testdb',
+                '--mysql-port', '3307'
+            ]);
+            expect(result.databases).toHaveLength(1);
+            expect(result.databases[0]).toMatchObject({
+                host: 'localhost',
+                username: 'root',
+                password: 'secret',
+                database: 'testdb',
+                port: 3307
+            });
+        });
+
+
+        it('should use environment variables for fallback', () => {
+            vi.stubEnv('MYSQL_HOST', 'env-host');
+            vi.stubEnv('MYSQL_USER', 'env-user');
+
+            const result = parseArgs([]);
+            // Partial config won't create a database entry unless user AND database are present
+            expect(result.databases).toHaveLength(0);
+
+            vi.unstubAllEnvs();
+        });
+
+        it('should print help and exit when --help flag is used', () => {
+            const result = parseArgs(['--help']);
+            expect(result.shouldExit).toBe(true);
+            expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('Usage: mysql-mcp [options]'));
+        });
+
+        it('should print help and exit when -h flag is used', () => {
+            const result = parseArgs(['-h']);
+            expect(result.shouldExit).toBe(true);
+            expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('Usage: mysql-mcp [options]'));
+        });
+
+        it('should use TOOL_FILTER environment variable', () => {
+            vi.stubEnv('TOOL_FILTER', '-admin');
+            const result = parseArgs([]);
+            expect(result.config.toolFilter).toBe('-admin');
+            vi.unstubAllEnvs();
+        });
+
+        it('should prefer MYSQL_MCP_TOOL_FILTER over TOOL_FILTER', () => {
+            vi.stubEnv('TOOL_FILTER', '-admin');
+            vi.stubEnv('MYSQL_MCP_TOOL_FILTER', '-security');
+            const result = parseArgs([]);
+            expect(result.config.toolFilter).toBe('-security');
+            vi.unstubAllEnvs();
+        });
+
+        it('should load oauth config from environment variables', () => {
+            vi.stubEnv('OAUTH_ENABLED', 'true');
+            vi.stubEnv('OAUTH_ISSUER', 'https://env-issuer.com');
+            vi.stubEnv('OAUTH_AUDIENCE', 'env-aud');
+            vi.stubEnv('OAUTH_JWKS_URI', 'https://jwks');
+            vi.stubEnv('OAUTH_CLOCK_TOLERANCE', '120');
+
+            const result = parseArgs([]);
+
+            expect(result.oauth).toBeDefined();
+            expect(result.oauth?.enabled).toBe(true);
+            expect(result.oauth?.issuer).toBe('https://env-issuer.com');
+            expect(result.oauth?.audience).toBe('env-aud');
+            expect(result.oauth?.jwksUri).toBe('https://jwks');
+            expect(result.oauth?.clockTolerance).toBe(120);
+
+            vi.unstubAllEnvs();
+        });
+
+        it('should build database config from environment variables if no arguments provided', () => {
+            vi.stubEnv('MYSQL_HOST', 'env-host');
+            vi.stubEnv('MYSQL_USER', 'env-user');
+            vi.stubEnv('MYSQL_PASSWORD', 'env-pass');
+            vi.stubEnv('MYSQL_DATABASE', 'env-db');
+            vi.stubEnv('MYSQL_PORT', '3307');
+            vi.stubEnv('MYSQL_POOL_SIZE', '20');
+
+            const result = parseArgs([]);
+            expect(result.databases).toHaveLength(1);
+            expect(result.databases[0]).toEqual(expect.objectContaining({
+                host: 'env-host',
+                username: 'env-user',
+                port: 3307,
+                database: 'env-db'
+            }));
+            expect(result.databases[0].pool?.connectionLimit).toBe(20);
+
+            vi.unstubAllEnvs();
+        });
+
+
+        it('should parse transport flags', () => {
+            const result = parseArgs(['--transport', 'sse', '--port', '8080']);
+            expect(result.config.transport).toBe('sse');
+            expect(result.config.port).toBe(8080);
+
+            const resultShort = parseArgs(['-t', 'http', '-p', '9090']);
+            expect(resultShort.config.transport).toBe('http');
+            expect(resultShort.config.port).toBe(9090);
+        });
+
+        it('should parse pool config flags', () => {
+            vi.stubEnv('MYSQL_HOST', 'localhost');
+            vi.stubEnv('MYSQL_USER', 'user');
+            vi.stubEnv('MYSQL_DATABASE', 'db');
+
+            const resultEnv = parseArgs([
+                '--pool-size', '25',
+                '--pool-timeout', '6000',
+                '--pool-queue-limit', '150'
+            ]);
+
+            expect(resultEnv.databases[0].pool?.connectionLimit).toBe(25);
+            expect(resultEnv.databases[0].pool?.acquireTimeout).toBe(6000);
+            expect(resultEnv.databases[0].pool?.queueLimit).toBe(150);
+
+            vi.unstubAllEnvs();
+        });
+
+        it('should parse OAuth flags', () => {
+            const result = parseArgs([
+                '--oauth-enabled',
+                '--oauth-issuer', 'https://auth.com',
+                '--oauth-audience', 'api',
+                '--oauth-jwks-uri', 'https://jwks',
+                '--oauth-clock-tolerance', '30'
+            ]);
+
+            expect(result.oauth).toBeDefined();
+            expect(result.oauth?.enabled).toBe(true);
+            expect(result.oauth?.issuer).toBe('https://auth.com');
+            expect(result.oauth?.audience).toBe('api');
+            expect(result.oauth?.jwksUri).toBe('https://jwks');
+            expect(result.oauth?.clockTolerance).toBe(30);
+        });
+
+        it('should exit error if value argument looks like a flag', () => {
+            // Case: --mysql-user -flag
+            expect(() => parseArgs(['--mysql-user', '-flag'])).toThrow('process.exit(1)');
+        });
+
+        it('should NOT add database if required fields are missing despite some being present', () => {
+            // Case: Host provided, but User missing in both CLI and Env
+            vi.stubEnv('MYSQL_DATABASE', 'env-db');
+            // No MYSQL_USER
+
+            const result = parseArgs(['--mysql-host', 'cli-host']);
+            expect(result.databases).toHaveLength(0);
+
+            vi.unstubAllEnvs();
+        });
+
+        it('should fallback to localhost if MYSQL_HOST is missing but others are present', () => {
+            vi.stubEnv('MYSQL_USER', 'env-user');
+            vi.stubEnv('MYSQL_DATABASE', 'env-db');
+            // No MYSQL_HOST
+
+            const result = parseArgs(['--mysql-user', 'cli-user']);
+
+            expect(result.databases[0].host).toBe('localhost');
+            expect(result.databases[0].username).toBe('cli-user');
+
+            vi.unstubAllEnvs();
+        });
+
+        it('should parse --version flag', () => {
+            const result = parseArgs(['--version']);
+            expect(result.shouldExit).toBe(true);
+            expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('mysql-mcp version'));
+        });
+
+        it('should print help when --help flag is used', () => {
+            const result = parseArgs(['--help']);
+            expect(result.shouldExit).toBe(true);
+            expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('Usage: mysql-mcp [options]'));
+        });
+    });
+});

package/src/cli/__tests__/main.test.ts

@@ -0,0 +1,193 @@
+import { describe, it, expect, vi, beforeEach, afterEach, type Mock } from 'vitest';
+import { main } from '../../cli.js';
+import { createServer } from '../../server/McpServer.js';
+import { MySQLAdapter } from '../../adapters/mysql/MySQLAdapter.js';
+
+// Mock dependencies
+vi.mock('../../server/McpServer.js');
+vi.mock('../../adapters/mysql/MySQLAdapter.js');
+vi.mock('../args.js', () => ({
+    parseArgs: vi.fn(() => ({
+        config: { name: 'test-server', version: '1.0.0' },
+        databases: [],
+        oauth: undefined,
+        shouldExit: false
+    }))
+}));
+
+// Mock process methods
+const originalExit = process.exit;
+
+describe('CLI Main', () => {
+    let mockServer: any;
+    let mockAdapter: any;
+    let mockExit: any;
+    let mockConsoleError: any;
+    let mockProcessOn: any;
+
+    // Custom error to simulate process.exit
+    class ExitError extends Error {
+        constructor(public code: number) {
+            super(`Process exited with code ${code}`);
+        }
+    }
+
+    beforeEach(() => {
+        // Reset mocks
+        vi.clearAllMocks();
+
+        // Setup mock server
+        mockServer = {
+            start: vi.fn().mockResolvedValue(undefined),
+            stop: vi.fn().mockResolvedValue(undefined),
+            registerAdapter: vi.fn()
+        };
+        (createServer as unknown as Mock).mockReturnValue(mockServer);
+
+        // Mock MySQLAdapter
+        mockAdapter = {
+            connect: vi.fn().mockResolvedValue(undefined),
+            disconnect: vi.fn().mockResolvedValue(undefined),
+            getCapabilities: vi.fn().mockReturnValue({}),
+            isConnected: vi.fn().mockReturnValue(true)
+        };
+        (MySQLAdapter as unknown as Mock).mockImplementation(function () { return mockAdapter; });
+
+        // Mock process.exit
+        mockExit = vi.fn().mockImplementation((code) => {
+            throw new ExitError(code);
+        });
+        Object.defineProperty(process, 'exit', { value: mockExit });
+
+        // Mock console.error
+        mockConsoleError = vi.fn();
+        console.error = mockConsoleError;
+
+        // Mock process.on
+        mockProcessOn = vi.fn();
+        process.on = mockProcessOn;
+    });
+
+    afterEach(() => {
+        if (originalExit) {
+            Object.defineProperty(process, 'exit', { value: originalExit });
+        }
+        vi.restoreAllMocks();
+    });
+
+    it('should exit if shouldExit is true', async () => {
+        await expect(main({
+            config: {},
+            databases: [],
+            oauth: undefined,
+            shouldExit: true
+        })).rejects.toThrow(/Process exited with code 0/);
+
+        expect(mockExit).toHaveBeenCalledWith(0);
+        expect(createServer).not.toHaveBeenCalled();
+    });
+
+    it('should exit with error if no databases specified', async () => {
+        await expect(main({
+            config: {},
+            databases: [],
+            oauth: undefined
+        })).rejects.toThrow(/Process exited with code 1/);
+
+        expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('Error: No database connection specified'));
+        expect(mockExit).toHaveBeenCalledWith(1);
+        expect(createServer).not.toHaveBeenCalled();
+    });
+
+    it('should start server with valid configuration', async () => {
+        const dbConfig = {
+            type: 'mysql' as const,
+            username: 'root',
+            password: 'password',
+            database: 'test_db'
+        };
+
+        await main({
+            config: { name: 'test-server' },
+            databases: [dbConfig],
+            oauth: undefined
+        });
+
+        expect(createServer).toHaveBeenCalledWith(expect.objectContaining({
+            name: 'test-server',
+            databases: [dbConfig]
+        }));
+        expect(MySQLAdapter).toHaveBeenCalled();
+        expect(mockAdapter.connect).toHaveBeenCalledWith(dbConfig);
+        expect(mockServer.registerAdapter).toHaveBeenCalledWith(mockAdapter, 'mysql:test_db');
+        expect(mockServer.start).toHaveBeenCalled();
+        expect(mockExit).not.toHaveBeenCalled();
+    });
+
+    it('should log OAuth status if enabled', async () => {
+        const dbConfig = { type: 'mysql' as const };
+        const oauthConfig = { enabled: true, issuer: 'http://test', audience: 'test' };
+
+        await main({
+            config: { name: 'test', version: '1.0.0' },
+            databases: [dbConfig],
+            oauth: oauthConfig
+        });
+
+        expect(mockConsoleError).toHaveBeenCalledWith('OAuth authentication enabled');
+    });
+
+    it('should handle adapter connection errors', async () => {
+        const dbConfig = { type: 'mysql' as const };
+        const error = new Error('Connection failed');
+        mockAdapter.connect.mockRejectedValue(error);
+
+        await expect(main({
+            config: {},
+            databases: [dbConfig],
+            oauth: undefined
+        })).rejects.toThrow(/Process exited with code 1/);
+
+        expect(mockConsoleError).toHaveBeenCalledWith('Fatal error:', error);
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should register signal handlers for graceful shutdown', async () => {
+        const dbConfig = { type: 'mysql' as const };
+
+        await main({
+            config: {},
+            databases: [dbConfig],
+            oauth: undefined
+        });
+
+        expect(mockProcessOn).toHaveBeenCalledWith('SIGINT', expect.any(Function));
+        expect(mockProcessOn).toHaveBeenCalledWith('SIGTERM', expect.any(Function));
+    });
+
+    it('should handle graceful shutdown correctly', async () => {
+        const dbConfig = { type: 'mysql' as const };
+
+        await main({
+            config: {},
+            databases: [dbConfig],
+            oauth: undefined
+        });
+
+        // Get the shutdown handler
+        const shutdownHandler = mockProcessOn.mock.calls.find((call: any[]) => call[0] === 'SIGINT')[1];
+
+        // Override mockExit to not throw for this test to avoid Unhandled Rejection in the void wrapper
+        mockExit.mockImplementation(() => { });
+
+        // Execute shutdown
+        shutdownHandler();
+
+        // Wait for async shutdown to loop
+        await new Promise(resolve => setTimeout(resolve, 0));
+
+        expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('Shutting down'));
+        expect(mockServer.stop).toHaveBeenCalled();
+        expect(mockExit).toHaveBeenCalledWith(0);
+    });
+});