add tests

Author: nirinchev

src/common/logger.ts

@@ -218,7 +218,7 @@ export class McpLogger extends LoggerBase {
     }
 }
 
-class CompositeLogger extends LoggerBase {
+export class CompositeLogger extends LoggerBase {
     // This is not a real logger type - it should not be used anyway.
     protected type: LoggerType = "composite" as unknown as LoggerType;
 

tests/unit/logger.test.ts

@@ -0,0 +1,164 @@
+import { describe, beforeEach, afterEach, vi, MockInstance, it, expect } from "vitest";
+import { CompositeLogger, ConsoleLogger, LoggerType, LogId, McpLogger } from "../../src/common/logger.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+describe("Logger", () => {
+    let consoleErrorSpy: MockInstance<typeof console.error>;
+    let consoleLogger: ConsoleLogger;
+
+    let mcpLoggerSpy: MockInstance;
+    let mcpLogger: McpLogger;
+
+    beforeEach(() => {
+        // Mock console.error before creating the ConsoleLogger
+        consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+        consoleLogger = new ConsoleLogger();
+
+        mcpLoggerSpy = vi.fn();
+        mcpLogger = new McpLogger({
+            server: {
+                sendLoggingMessage: mcpLoggerSpy,
+            },
+            isConnected: () => true,
+        } as unknown as McpServer);
+    });
+
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    const getLastMcpLogMessage = (): string => {
+        return (mcpLoggerSpy.mock.lastCall?.[0] as { data: string }).data;
+    };
+
+    const getLastConsoleMessage = (): string => {
+        return consoleErrorSpy.mock.lastCall?.[0] as string;
+    };
+
+    const mockSensitivePayload = {
+        id: LogId.serverInitialized,
+        context: "test",
+        message: "My email is [email protected]",
+    };
+
+    const expectLogMessageRedaction = (logMessage: string, expectRedacted: boolean): void => {
+        const expectedContain = expectRedacted ? "<email>" : "[email protected]";
+        const expectedNotContain = expectRedacted ? "[email protected]" : "<email>";
+
+        expect(logMessage).to.contain(expectedContain);
+        expect(logMessage).to.not.contain(expectedNotContain);
+    };
+
+    describe("redaction", () => {
+        it("redacts sensitive information by default", () => {
+            consoleLogger.info(mockSensitivePayload);
+
+            expect(consoleErrorSpy).toHaveBeenCalledOnce();
+
+            expectLogMessageRedaction(getLastConsoleMessage(), true);
+        });
+
+        it("does not redact sensitive information for mcp logger by default", () => {
+            mcpLogger.info(mockSensitivePayload);
+
+            expect(mcpLoggerSpy).toHaveBeenCalledOnce();
+
+            expectLogMessageRedaction(getLastMcpLogMessage(), false);
+        });
+
+        it("allows disabling redaction for all loggers", () => {
+            const payload = {
+                ...mockSensitivePayload,
+                noRedaction: true,
+            };
+
+            consoleLogger.debug(payload);
+            mcpLogger.error(payload);
+
+            expect(consoleErrorSpy).toHaveBeenCalledOnce();
+            expectLogMessageRedaction(getLastConsoleMessage(), false);
+
+            expect(mcpLoggerSpy).toHaveBeenCalledOnce();
+            expectLogMessageRedaction(getLastMcpLogMessage(), false);
+        });
+
+        it("allows forcing redaction for all loggers", () => {
+            const payload = {
+                ...mockSensitivePayload,
+                noRedaction: false,
+            };
+
+            consoleLogger.warning(payload);
+            mcpLogger.warning(payload);
+
+            expect(consoleErrorSpy).toHaveBeenCalledOnce();
+            expectLogMessageRedaction(getLastConsoleMessage(), true);
+
+            expect(mcpLoggerSpy).toHaveBeenCalledOnce();
+            expectLogMessageRedaction(getLastMcpLogMessage(), true);
+        });
+
+        it("allows disabling redaction for specific loggers", () => {
+            const payload = {
+                ...mockSensitivePayload,
+                noRedaction: "console" as LoggerType,
+            };
+
+            consoleLogger.debug(payload);
+            mcpLogger.debug(payload);
+
+            expect(consoleErrorSpy).toHaveBeenCalledOnce();
+            expectLogMessageRedaction(getLastConsoleMessage(), false);
+
+            expect(mcpLoggerSpy).toHaveBeenCalledOnce();
+            expectLogMessageRedaction(getLastMcpLogMessage(), true);
+        });
+
+        it("allows disabling redaction for multiple loggers", () => {
+            const payload = {
+                ...mockSensitivePayload,
+                noRedaction: ["console", "mcp"] as LoggerType[],
+            };
+
+            consoleLogger.notice(payload);
+            mcpLogger.notice(payload);
+
+            expect(consoleErrorSpy).toHaveBeenCalledOnce();
+            expectLogMessageRedaction(getLastConsoleMessage(), false);
+
+            expect(mcpLoggerSpy).toHaveBeenCalledOnce();
+            expectLogMessageRedaction(getLastMcpLogMessage(), false);
+        });
+
+        describe("CompositeLogger", () => {
+            it("propagates noRedaction config to child loggers", () => {
+                const compositeLogger = new CompositeLogger(consoleLogger, mcpLogger);
+                compositeLogger.info({
+                    ...mockSensitivePayload,
+                    noRedaction: true,
+                });
+
+                expect(consoleErrorSpy).toHaveBeenCalledOnce();
+                expectLogMessageRedaction(getLastConsoleMessage(), false);
+
+                expect(mcpLoggerSpy).toHaveBeenCalledOnce();
+                expectLogMessageRedaction(getLastMcpLogMessage(), false);
+            });
+
+            it("supports redaction for a subset of its child loggers", () => {
+                const compositeLogger = new CompositeLogger(consoleLogger, mcpLogger);
+                compositeLogger.info({
+                    ...mockSensitivePayload,
+                    noRedaction: ["console", "disk"],
+                });
+
+                expect(consoleErrorSpy).toHaveBeenCalledOnce();
+                expectLogMessageRedaction(getLastConsoleMessage(), false);
+
+                expect(mcpLoggerSpy).toHaveBeenCalledOnce();
+                expectLogMessageRedaction(getLastMcpLogMessage(), true);
+            });
+        });
+    });
+});

tests/unit/telemetry.test.ts

@@ -250,11 +250,11 @@ describe("Telemetry", () => {
                     expect(telemetry["isBufferingEvents"]).toBe(false);
                     expect(telemetry.getCommonProperties().device_id).toBe("unknown");
 
-                    expect(loggerSpy).toHaveBeenCalledWith(
-                        LogId.telemetryDeviceIdFailure,
-                        "telemetry",
-                        "Error: Failed to get device ID"
-                    );
+                    expect(loggerSpy).toHaveBeenCalledWith({
+                        id: LogId.telemetryDeviceIdFailure,
+                        context: "telemetry",
+                        message: "Error: Failed to get device ID",
+                    });
                 });
 
                 it("should timeout if machine ID resolution takes too long", async () => {
@@ -277,11 +277,12 @@ describe("Telemetry", () => {
 
                     expect(telemetry.getCommonProperties().device_id).toBe("unknown");
                     expect(telemetry["isBufferingEvents"]).toBe(false);
-                    expect(loggerSpy).toHaveBeenCalledWith(
-                        LogId.telemetryDeviceIdTimeout,
-                        "telemetry",
-                        "Device ID retrieval timed out"
-                    );
+                    expect(loggerSpy).toHaveBeenCalledWith({
+                        id: LogId.telemetryDeviceIdTimeout,
+                        context: "telemetry",
+                        message: "Device ID retrieval timed out",
+                        noRedaction: true,
+                    });
                 });
             });
         });