chore: update dependencies and add vitest configuration for testing

Author: devakone

package-lock.json

@@ -13,7 +13,9 @@
     "dev": "ts-node src/index.ts",
     "lint": "eslint 'src/**/*.ts'",
     "format": "prettier --write 'src/**/*.ts'",
-    "test": "echo \"No tests defined\" && exit 0",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -42,7 +44,8 @@
   "devDependencies": {
     "@types/node": "^18.16.1",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.4"
+    "typescript": "^5.0.4",
+    "vitest": "^3.1.1"
   },
   "files": [
     "dist",

package.json

@@ -1,33 +1,15 @@
 import { z } from "zod";
-import { createPool, Pool, PoolOptions } from "mysql2/promise";
+import { Pool } from "mysql2/promise";
 import { Environment, InfoParams, DatabaseInfo } from "../types/index.js";
 import { config } from "dotenv";
+import { pools } from "../db/pools.js";
 
 config();
 
 export const infoToolName = "info";
 export const infoToolDescription = "Get information about MySQL databases";
 export const InfoToolSchema = InfoParams;
 
-// Connection pools for each environment
-const pools = new Map<Environment, Pool>();
-
-// Initialize pools
-Object.values(Environment.enum).forEach((env) => {
-  const config: PoolOptions = {
-    host: process.env[`${env.toUpperCase()}_DB_HOST`],
-    user: process.env[`${env.toUpperCase()}_DB_USER`],
-    password: process.env[`${env.toUpperCase()}_DB_PASS`],
-    database: process.env[`${env.toUpperCase()}_DB_NAME`],
-    ssl: process.env[`${env.toUpperCase()}_DB_SSL`] === "true" ? {} : undefined,
-    connectionLimit: 5,
-  };
-
-  if (config.host && config.user && config.password && config.database) {
-    pools.set(env, createPool(config));
-  }
-});
-
 export async function runInfoTool(params: z.infer<typeof InfoToolSchema>): Promise<{ content: { type: string; text: string }[] }> {
   const { environment } = params;
 

src/tools/info.ts

@@ -11,7 +11,7 @@ export const queryToolDescription = "Execute read-only SQL queries against MySQL
 export const QueryToolSchema = QueryParams;
 
 // Validate query is read-only
-function isReadOnlyQuery(sql: string): boolean {
+export function isReadOnlyQuery(sql: string): boolean {
   const upperSql = sql.trim().toUpperCase();
   return upperSql.startsWith("SELECT") || upperSql.startsWith("SHOW") || 
          upperSql.startsWith("DESCRIBE") || upperSql.startsWith("DESC");

src/tools/query.ts

@@ -0,0 +1,43 @@
+# MySQL MCP Server Test Fixes
+
+This document describes the issues that were fixed in the test suite of the MySQL MCP Server project.
+
+## Issues Fixed
+
+1. **Exported the `isReadOnlyQuery` function in query.ts**:
+   - The function was being imported in the tests but wasn't exported from the source file
+   - Fixed by adding the `export` keyword to the function declaration
+
+2. **Fixed the Mocking Approach**:
+   - Previous test implementation was using `vi.mocked()` which was causing type errors
+   - The mocks were not properly set up for the connection and query methods
+   - We simplified the mock implementation with pure JavaScript functions instead of relying on jest/vitest mocking APIs
+
+3. **Simplified Test State Management**:
+   - Added global variables to track mock state (e.g., `releaseCalled`, `queryCount`)
+   - Used these variables to verify that the expected operations were performed
+   - Made tests more readable and less brittle
+
+4. **Fixed the `info.ts` Module**:
+   - The module was creating its own pools instead of importing from db/pools.js
+   - Updated to import the pools from the correct location, making it consistent with other modules
+
+## Improved Test Patterns
+
+The tests now use a more reliable approach:
+
+1. **Manual Mocking**: Instead of relying on mock functions with `mockResolvedValueOnce`, etc., we use pure JavaScript functions with conditional logic.
+
+2. **Clear State Management**: Each test resets the mock state before running, preventing test interdependence.
+
+3. **Fixed Environmental Setup**: Tests now properly set up the environment and clean up after themselves.
+
+## Running Tests
+
+Tests can be run with:
+
+```bash
+npm test
+```
+
+All tests now pass successfully. 

tests/tools/README.md

@@ -0,0 +1,81 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { runEnvironmentsTool } from '../../src/tools/environments.js';
+import { Environment } from '../../src/types/index.js';
+
+describe('environments tool', () => {
+  const originalEnv = process.env;
+  
+  beforeEach(() => {
+    vi.resetModules();
+    process.env = { ...originalEnv };
+    
+    // Clean any environment-specific variables
+    Object.keys(process.env).forEach(key => {
+      if (key.includes('_DB_')) {
+        delete process.env[key];
+      }
+    });
+    
+    // Mock stderr to suppress debug output during tests
+    vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+  });
+  
+  afterEach(() => {
+    process.env = originalEnv;
+    vi.restoreAllMocks();
+  });
+  
+  it('should return empty environments when no DB configs are set', async () => {
+    const result = await runEnvironmentsTool();
+    expect(result).toHaveProperty('content');
+    expect(result.content).toHaveLength(1);
+    expect(result.content[0].type).toBe('text');
+    
+    const parsedContent = JSON.parse(result.content[0].text);
+    expect(parsedContent.environments).toEqual([]);
+    expect(parsedContent.count).toBe(0);
+  });
+  
+  it('should detect local environment when LOCAL_DB_* vars are set', async () => {
+    // Set up local environment variables
+    process.env.LOCAL_DB_HOST = 'localhost';
+    process.env.LOCAL_DB_USER = 'root';
+    process.env.LOCAL_DB_NAME = 'test';
+    
+    const result = await runEnvironmentsTool();
+    const parsedContent = JSON.parse(result.content[0].text);
+    
+    expect(parsedContent.environments).toContain('local');
+    expect(parsedContent.count).toBe(1);
+    expect(parsedContent.debug.envVars).toHaveProperty('LOCAL_DB_HOST', 'localhost');
+  });
+  
+  it('should detect multiple environments when multiple DB configs are set', async () => {
+    // Set up environment variables for multiple environments
+    process.env.LOCAL_DB_HOST = 'localhost';
+    process.env.LOCAL_DB_USER = 'root';
+    process.env.LOCAL_DB_NAME = 'test';
+    
+    process.env.DEVELOPMENT_DB_HOST = 'dev.example.com';
+    process.env.DEVELOPMENT_DB_USER = 'dev_user';
+    process.env.DEVELOPMENT_DB_NAME = 'dev_db';
+    
+    const result = await runEnvironmentsTool();
+    const parsedContent = JSON.parse(result.content[0].text);
+    
+    expect(parsedContent.environments).toContain('local');
+    expect(parsedContent.environments).toContain('development');
+    expect(parsedContent.environments).not.toContain('staging');
+    expect(parsedContent.environments).not.toContain('production');
+    expect(parsedContent.count).toBe(2);
+  });
+  
+  it('should handle errors gracefully', async () => {
+    // Mock Environment.enum to throw an error
+    vi.spyOn(Environment, 'enum', 'get').mockImplementation(() => {
+      throw new Error('Test error');
+    });
+    
+    await expect(runEnvironmentsTool()).rejects.toThrow('Test error');
+  });
+}); 

tests/tools/environments.test.ts

@@ -0,0 +1,136 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { runInfoTool } from '../../src/tools/info.js';
+import { RowDataPacket, FieldPacket } from 'mysql2/promise';
+
+// Track mock state
+let releaseCalled = false;
+let queryCount = 0;
+let mockQueryShouldFail = false;
+
+// Mock responses for each query call
+const mockResponses = [
+  // Version query
+  [[{ version: '8.0.32' } as RowDataPacket], [] as FieldPacket[]],
+  
+  // Status query
+  [[
+    { Variable_name: 'Uptime', Value: '12345' } as RowDataPacket,
+    { Variable_name: 'Threads_connected', Value: '10' } as RowDataPacket
+  ], [] as FieldPacket[]],
+  
+  // Variables query
+  [[
+    { Variable_name: 'max_connections', Value: '151' } as RowDataPacket,
+    { Variable_name: 'version', Value: '8.0.32' } as RowDataPacket
+  ], [] as FieldPacket[]],
+  
+  // Process list query
+  [[
+    { Id: 1, User: 'root', Host: 'localhost', Command: 'Query', Time: 0 } as RowDataPacket
+  ], [] as FieldPacket[]],
+  
+  // Databases query
+  [[
+    { Database: 'mysql' } as RowDataPacket,
+    { Database: 'information_schema' } as RowDataPacket,
+    { Database: 'test' } as RowDataPacket
+  ], [] as FieldPacket[]]
+];
+
+// Mock the DB pools module
+vi.mock('../../src/db/pools.js', () => {
+  const mockPools = new Map();
+  
+  // Mock connection with simple functions
+  const mockConnection = {
+    query: (sql) => {
+      if (mockQueryShouldFail) {
+        return Promise.reject(new Error('Connection error'));
+      }
+      
+      // Return the appropriate response based on the query count
+      const response = mockResponses[queryCount];
+      queryCount++;
+      return Promise.resolve(response);
+    },
+    release: () => {
+      releaseCalled = true;
+      return Promise.resolve();
+    }
+  };
+  
+  // Mock pool
+  const mockPool = {
+    getConnection: () => Promise.resolve(mockConnection),
+    end: () => Promise.resolve()
+  };
+  
+  // Add mock pool for local environment
+  mockPools.set('local', mockPool);
+  
+  return { 
+    pools: mockPools
+  };
+});
+
+describe('info tool', () => {
+  const originalEnv = process.env;
+  
+  beforeEach(() => {
+    vi.resetModules();
+    process.env = { ...originalEnv };
+    
+    // Reset mock state
+    releaseCalled = false;
+    queryCount = 0;
+    mockQueryShouldFail = false;
+    
+    // Mock stderr to suppress debug output during tests
+    vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+  });
+  
+  afterEach(() => {
+    process.env = originalEnv;
+    vi.restoreAllMocks();
+  });
+  
+  it('should retrieve and format database information', async () => {
+    // Run the info tool
+    const result = await runInfoTool({ environment: 'local' });
+    
+    // Verify result structure
+    expect(result).toHaveProperty('content');
+    expect(result.content).toHaveLength(1);
+    expect(result.content[0].type).toBe('text');
+    
+    // Parse and verify content
+    const parsedContent = JSON.parse(result.content[0].text);
+    expect(parsedContent).toHaveProperty('version', '8.0.32');
+    expect(parsedContent).toHaveProperty('status', 'Up 12345 seconds');
+    expect(parsedContent.variables).toHaveProperty('max_connections', '151');
+    expect(parsedContent.processlist).toHaveLength(1);
+    expect(parsedContent.databases).toContain('mysql');
+    expect(parsedContent.databases).toContain('test');
+    
+    // Verify connection was released
+    expect(releaseCalled).toBe(true);
+    
+    // Verify all queries were called
+    expect(queryCount).toBe(5);
+  });
+  
+  it('should throw error when environment not found', async () => {
+    await expect(runInfoTool({ environment: 'production' }))
+      .rejects.toThrow('No connection pool available for environment: production');
+  });
+  
+  it('should handle database query errors', async () => {
+    mockQueryShouldFail = true;
+    
+    await expect(runInfoTool({ environment: 'local' }))
+      .rejects.toThrow('Failed to get database info: Connection error');
+    
+    // Verify connection was released even after error
+    expect(releaseCalled).toBe(true);
+  });
+});