/**
* mysql-mcp - McpServer Unit Tests
*
* Tests for MCP server lifecycle, adapter registration,
* tool filtering integration, and configuration.
*/
import { describe, it, expect, beforeEach, vi } from "vitest";
import {
McpServer,
createServer,
parseMySQLConnectionString,
DEFAULT_CONFIG,
} from "../McpServer.js";
import { createMockMySQLAdapter } from "../../__tests__/mocks/index.js";
// Mock the StdioServerTransport
vi.mock("@modelcontextprotocol/sdk/server/stdio.js", () => ({
StdioServerTransport: class MockStdioTransport {},
}));
// Mock HTTP transport
const mockHttpTransport = {
start: vi.fn(),
stop: vi.fn(),
};
vi.mock("../../transports/http.js", () => ({
createHttpTransport: vi.fn(() => mockHttpTransport),
}));
// Mock OAuth dependencies
vi.mock("../auth/OAuthResourceServer.js", () => ({
OAuthResourceServer: class MockOAuthResourceServer {
constructor(config: any) {}
},
}));
vi.mock("../auth/TokenValidator.js", () => ({
TokenValidator: class MockTokenValidator {
constructor(config: any) {}
},
}));
// Mock the MCP SDK server with a proper class - capture constructor args
let lastMockMcpServerOptions: unknown = null;
vi.mock("@modelcontextprotocol/sdk/server/mcp.js", () => ({
McpServer: class MockMcpServer {
connect = vi.fn().mockResolvedValue(undefined);
close = vi.fn().mockResolvedValue(undefined);
tool = vi.fn();
resource = vi.fn();
prompt = vi.fn();
constructor(_serverInfo: unknown, options: unknown) {
lastMockMcpServerOptions = options;
}
},
}));
// Mock logger
vi.mock("../../utils/logger.js", () => ({
logger: {
info: vi.fn(),
warn: vi.fn(),
error: vi.fn(),
debug: vi.fn(),
},
}));
// Mock MCP logging
vi.mock("../../logging/McpLogging.js", () => ({
mcpLogger: {
setServer: vi.fn(),
setConnected: vi.fn(),
info: vi.fn(),
notice: vi.fn(),
},
}));
// Mock progress reporter
vi.mock("../../progress/ProgressReporter.js", () => ({
progressFactory: {
setServer: vi.fn(),
},
}));
describe("DEFAULT_CONFIG", () => {
it("should have correct default values", () => {
expect(DEFAULT_CONFIG.name).toBe("mysql-mcp");
expect(DEFAULT_CONFIG.version).toBe("0.1.0");
expect(DEFAULT_CONFIG.transport).toBe("stdio");
expect(DEFAULT_CONFIG.databases).toEqual([]);
});
});
describe("McpServer", () => {
let server: McpServer;
beforeEach(() => {
vi.clearAllMocks();
server = new McpServer();
});
describe("constructor", () => {
it("should create server with default config", () => {
const config = server.getConfig();
expect(config.name).toBe("mysql-mcp");
expect(config.version).toBe("0.1.0");
expect(config.transport).toBe("stdio");
});
it("should merge custom config with defaults", () => {
const customServer = new McpServer({
name: "custom-server",
transport: "http",
});
const config = customServer.getConfig();
expect(config.name).toBe("custom-server");
expect(config.transport).toBe("http");
expect(config.version).toBe("0.1.0"); // Default preserved
});
it("should parse tool filter from config", () => {
const filteredServer = new McpServer({
toolFilter: "-base,+starter",
});
const filter = filteredServer.getToolFilter();
expect(filter.rules.length).toBeGreaterThan(0);
});
it("should pass instructions to SDK server", () => {
new McpServer();
expect(lastMockMcpServerOptions).toHaveProperty("instructions");
expect(
(lastMockMcpServerOptions as { instructions: string }).instructions,
).toContain("mysql-mcp Usage Instructions");
});
});
describe("registerAdapter", () => {
it("should register an adapter", () => {
const mockAdapter = createMockMySQLAdapter();
server.registerAdapter(
mockAdapter as unknown as Parameters<typeof server.registerAdapter>[0],
);
expect(server.getAdapter("mysql:default")).toBe(mockAdapter);
});
it("should register adapter with custom alias", () => {
const mockAdapter = createMockMySQLAdapter();
server.registerAdapter(
mockAdapter as unknown as Parameters<typeof server.registerAdapter>[0],
"primary-db",
);
expect(server.getAdapter("primary-db")).toBe(mockAdapter);
});
it("should not register duplicate adapters", () => {
const mockAdapter = createMockMySQLAdapter();
server.registerAdapter(
mockAdapter as unknown as Parameters<typeof server.registerAdapter>[0],
);
server.registerAdapter(
mockAdapter as unknown as Parameters<typeof server.registerAdapter>[0],
); // Should warn but not fail
expect(server.getAdapters().size).toBe(1);
});
});
describe("getAdapter", () => {
it("should return undefined for non-existent adapter", () => {
expect(server.getAdapter("non-existent")).toBeUndefined();
});
});
describe("getAdapters", () => {
it("should return empty map initially", () => {
expect(server.getAdapters().size).toBe(0);
});
it("should return all registered adapters", () => {
server.registerAdapter(
createMockMySQLAdapter() as unknown as Parameters<
typeof server.registerAdapter
>[0],
"db1",
);
server.registerAdapter(
createMockMySQLAdapter() as unknown as Parameters<
typeof server.registerAdapter
>[0],
"db2",
);
expect(server.getAdapters().size).toBe(2);
});
});
describe("start", () => {
it("should start the server with stdio transport by default", async () => {
await server.start();
expect(server.isRunning()).toBe(true);
});
it("should start with http transport", async () => {
const httpServer = new McpServer({
transport: "http",
port: 8080,
});
await httpServer.start();
expect(httpServer.isRunning()).toBe(true);
// Verify http transport was created and started
const { createHttpTransport } = await import("../../transports/http.js");
expect(createHttpTransport).toHaveBeenCalledWith(
expect.objectContaining({ port: 8080 }),
expect.any(Function),
);
expect(mockHttpTransport.start).toHaveBeenCalled();
});
it("should configure OAuth when enabled", async () => {
const oauthServer = new McpServer({
transport: "http",
oauth: {
enabled: true,
issuer: "https://auth.example.com",
audience: "test-audience",
jwksUri: "https://auth.example.com/.well-known/jwks.json",
},
});
await oauthServer.start();
const { createHttpTransport } = await import("../../transports/http.js");
expect(createHttpTransport).toHaveBeenCalledWith(
expect.objectContaining({
resourceServer: expect.any(Object),
tokenValidator: expect.any(Object),
}),
expect.any(Function),
);
});
it("should throw if OAuth enabled but missing config", async () => {
const badConfigServer = new McpServer({
transport: "http",
oauth: {
enabled: true,
// Missing issuer/audience
} as any,
});
await expect(badConfigServer.start()).rejects.toThrow();
});
it("should fail if transport start fails", async () => {
mockHttpTransport.start.mockRejectedValueOnce(new Error("Port in use"));
const httpServer = new McpServer({ transport: "http" });
await expect(httpServer.start()).rejects.toThrow("Port in use");
expect(httpServer.isRunning()).toBe(false);
});
it("should not start twice", async () => {
await server.start();
await server.start(); // Should warn but not fail
expect(server.isRunning()).toBe(true);
});
});
describe("stop", () => {
it("should stop the server", async () => {
await server.start();
expect(server.isRunning()).toBe(true);
await server.stop();
expect(server.isRunning()).toBe(false);
});
it("should stop active transport", async () => {
const httpServer = new McpServer({ transport: "http" });
await httpServer.start();
await httpServer.stop();
expect(mockHttpTransport.stop).toHaveBeenCalled();
});
it("should safely handle transport stop errors", async () => {
const httpServer = new McpServer({ transport: "http" });
await httpServer.start();
mockHttpTransport.stop.mockRejectedValueOnce(new Error("Stop failed"));
await httpServer.stop(); // Should not throw
expect(httpServer.isRunning()).toBe(false);
// cleanup for other tests
mockHttpTransport.stop.mockResolvedValue(undefined);
});
it("should do nothing if not started", async () => {
await server.stop(); // Should not throw
expect(server.isRunning()).toBe(false);
});
it("should disconnect all adapters", async () => {
const mockAdapter = createMockMySQLAdapter();
server.registerAdapter(
mockAdapter as unknown as Parameters<typeof server.registerAdapter>[0],
);
await server.start();
await server.stop();
expect(mockAdapter.disconnect).toHaveBeenCalled();
});
});
describe("getConfig", () => {
it("should return a copy of config", () => {
const config1 = server.getConfig();
const config2 = server.getConfig();
expect(config1).not.toBe(config2);
expect(config1).toEqual(config2);
});
});
describe("getToolFilter", () => {
it("should return tool filter config", () => {
const filter = server.getToolFilter();
expect(filter).toHaveProperty("enabledTools");
expect(filter).toHaveProperty("rules");
});
});
describe("isRunning", () => {
it("should return false initially", () => {
expect(server.isRunning()).toBe(false);
});
});
describe("getSdkServer", () => {
it("should return the SDK server instance", () => {
const sdk = server.getSdkServer();
expect(sdk).toBeDefined();
});
});
});
describe("createServer", () => {
it("should create a server instance", () => {
const server = createServer();
expect(server).toBeInstanceOf(McpServer);
});
it("should accept custom config", () => {
const server = createServer({ name: "test-server" });
expect(server.getConfig().name).toBe("test-server");
});
});
describe("parseMySQLConnectionString", () => {
it("should parse basic connection string", () => {
const config = parseMySQLConnectionString(
"mysql://user:password@localhost:3306/testdb",
);
expect(config.type).toBe("mysql");
expect(config.host).toBe("localhost");
expect(config.port).toBe(3306);
expect(config.username).toBe("user");
expect(config.password).toBe("password");
expect(config.database).toBe("testdb");
});
it("should handle default port", () => {
const config = parseMySQLConnectionString(
"mysql://user:password@localhost/testdb",
);
expect(config.port).toBe(3306);
});
it("should decode URL-encoded credentials", () => {
const config = parseMySQLConnectionString(
"mysql://user%40domain:p%40ss%2Fword@localhost/db",
);
expect(config.username).toBe("user@domain");
expect(config.password).toBe("p@ss/word");
});
it("should parse query parameters as options", () => {
const config = parseMySQLConnectionString(
"mysql://user:pass@localhost/db?ssl=true&timeout=5000",
);
expect(config.options).toHaveProperty("ssl", "true");
expect(config.options).toHaveProperty("timeout", "5000");
});
it("should handle different hosts", () => {
const config1 = parseMySQLConnectionString(
"mysql://u:p@host.docker.internal:3306/db",
);
expect(config1.host).toBe("host.docker.internal");
const config2 = parseMySQLConnectionString(
"mysql://u:p@192.168.1.100:3306/db",
);
expect(config2.host).toBe("192.168.1.100");
const config3 = parseMySQLConnectionString(
"mysql://u:p@db.example.com:3306/db",
);
expect(config3.host).toBe("db.example.com");
});
});
