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);
});
});
