/**
* mysql-mcp - MCP Logging Unit Tests
*
* Tests for McpLogger functionality including log level filtering,
* configuration methods, and message sending.
*/
import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
// Create a fresh McpLogger for each test by importing the class directly
// We need to test the class, not the singleton
describe("McpLogger", () => {
let McpLogger: typeof import("../McpLogging.js").mcpLogger;
let mockServer: {
sendLoggingMessage: ReturnType<typeof vi.fn>;
};
beforeEach(async () => {
vi.clearAllMocks();
// Import fresh module for each test
vi.resetModules();
const module = await import("../McpLogging.js");
McpLogger = module.mcpLogger;
mockServer = {
sendLoggingMessage: vi.fn(),
};
});
afterEach(() => {
vi.resetModules();
});
describe("Configuration Methods", () => {
it("should allow setting the server", () => {
expect(() => McpLogger.setServer(mockServer as never)).not.toThrow();
});
it("should allow setting the logger name", () => {
expect(() => McpLogger.setLoggerName("test-logger")).not.toThrow();
});
it("should allow enabling/disabling logging", () => {
expect(() => McpLogger.setEnabled(false)).not.toThrow();
expect(() => McpLogger.setEnabled(true)).not.toThrow();
});
it("should allow setting minimum log level", () => {
expect(() => McpLogger.setMinLevel("debug")).not.toThrow();
expect(() => McpLogger.setMinLevel("error")).not.toThrow();
});
});
describe("Log Level Filtering", () => {
beforeEach(() => {
McpLogger.setServer(mockServer as never);
McpLogger.setEnabled(true);
McpLogger.setConnected(true);
});
it("should log messages at or above minimum level", () => {
McpLogger.setMinLevel("info");
McpLogger.info("test info message");
expect(mockServer.sendLoggingMessage).toHaveBeenCalledWith(
expect.objectContaining({
level: "info",
data: "test info message",
}),
);
});
it("should not log messages below minimum level", () => {
McpLogger.setMinLevel("warning");
McpLogger.debug("debug message");
McpLogger.info("info message");
expect(mockServer.sendLoggingMessage).not.toHaveBeenCalled();
});
it("should respect debug level filtering", () => {
McpLogger.setMinLevel("debug");
McpLogger.debug("debug message");
expect(mockServer.sendLoggingMessage).toHaveBeenCalledWith(
expect.objectContaining({ level: "debug" }),
);
});
it("should respect error level filtering", () => {
McpLogger.setMinLevel("error");
McpLogger.warning("warning message");
McpLogger.error("error message");
expect(mockServer.sendLoggingMessage).toHaveBeenCalledTimes(1);
expect(mockServer.sendLoggingMessage).toHaveBeenCalledWith(
expect.objectContaining({ level: "error" }),
);
});
});
describe("Convenience Methods", () => {
beforeEach(() => {
McpLogger.setServer(mockServer as never);
McpLogger.setEnabled(true);
McpLogger.setConnected(true);
McpLogger.setMinLevel("debug");
});
it("should call debug with correct level", () => {
McpLogger.debug("debug message");
expect(mockServer.sendLoggingMessage).toHaveBeenCalledWith(
expect.objectContaining({ level: "debug" }),
);
});
it("should call info with correct level", () => {
McpLogger.info("info message");
expect(mockServer.sendLoggingMessage).toHaveBeenCalledWith(
expect.objectContaining({ level: "info" }),
);
});
it("should call notice with correct level", () => {
McpLogger.notice("notice message");
expect(mockServer.sendLoggingMessage).toHaveBeenCalledWith(
expect.objectContaining({ level: "notice" }),
);
});
it("should call warning with correct level", () => {
McpLogger.warning("warning message");
expect(mockServer.sendLoggingMessage).toHaveBeenCalledWith(
expect.objectContaining({ level: "warning" }),
);
});
it("should call error with correct level", () => {
McpLogger.error("error message");
expect(mockServer.sendLoggingMessage).toHaveBeenCalledWith(
expect.objectContaining({ level: "error" }),
);
});
it("should call critical with correct level", () => {
McpLogger.critical("critical message");
expect(mockServer.sendLoggingMessage).toHaveBeenCalledWith(
expect.objectContaining({ level: "critical" }),
);
});
it("should call alert with correct level", () => {
McpLogger.alert("alert message");
expect(mockServer.sendLoggingMessage).toHaveBeenCalledWith(
expect.objectContaining({ level: "alert" }),
);
});
it("should call emergency with correct level", () => {
McpLogger.emergency("emergency message");
expect(mockServer.sendLoggingMessage).toHaveBeenCalledWith(
expect.objectContaining({ level: "emergency" }),
);
});
});
describe("Data Handling", () => {
beforeEach(() => {
McpLogger.setServer(mockServer as never);
McpLogger.setEnabled(true);
McpLogger.setConnected(true);
McpLogger.setMinLevel("debug");
});
it("should send message as string when no data provided", () => {
McpLogger.info("simple message");
expect(mockServer.sendLoggingMessage).toHaveBeenCalledWith(
expect.objectContaining({
data: "simple message",
}),
);
});
it("should include additional data in message", () => {
McpLogger.info("message with data", { key: "value", count: 42 });
expect(mockServer.sendLoggingMessage).toHaveBeenCalledWith(
expect.objectContaining({
data: expect.objectContaining({
message: "message with data",
key: "value",
count: 42,
}),
}),
);
});
});
describe("Disabled States", () => {
it("should not log when disabled", () => {
McpLogger.setServer(mockServer as never);
McpLogger.setEnabled(false);
McpLogger.info("should not be logged");
expect(mockServer.sendLoggingMessage).not.toHaveBeenCalled();
});
it("should not log when server not set", () => {
McpLogger.setEnabled(true);
// Don't set server
McpLogger.info("should not be logged");
expect(mockServer.sendLoggingMessage).not.toHaveBeenCalled();
});
it("should handle sendLoggingMessage errors gracefully", () => {
McpLogger.setServer(mockServer as never);
McpLogger.setEnabled(true);
McpLogger.setConnected(true);
mockServer.sendLoggingMessage.mockImplementation(() => {
throw new Error("Transport error");
});
// Should not throw
expect(() => McpLogger.info("test")).not.toThrow();
});
});
describe("Logger Name", () => {
beforeEach(() => {
McpLogger.setServer(mockServer as never);
McpLogger.setEnabled(true);
McpLogger.setConnected(true);
McpLogger.setMinLevel("debug");
});
it("should use default logger name", () => {
McpLogger.info("test");
expect(mockServer.sendLoggingMessage).toHaveBeenCalledWith(
expect.objectContaining({
logger: "mysql-mcp",
}),
);
});
it("should use custom logger name when set", () => {
McpLogger.setLoggerName("custom-logger");
McpLogger.info("test");
expect(mockServer.sendLoggingMessage).toHaveBeenCalledWith(
expect.objectContaining({
logger: "custom-logger",
}),
);
});
});
});
