Jun 16, 2025 · Jun 16, 2025 · Jun 16, 2025 · Jun 16, 2025 · Jun 16, 2025 · Jun 16, 2025
diff --git a/src/error.test.ts b/src/error.test.ts
 X509_ERR_CODE,
 getErrorDetail,
 } from "./error";
 import { createMockOutputChannelWithLogger } from "./test-helpers";

 // Before each test we make a request to sanity check that we really get the
 // error we are expecting, then we run it through CertificateError.
 }),
 }));

 // Use a mock logger that throws on error messages to ensure tests fail if unexpected logs occur
 const logger = {
 writeToCoderOutputChannel(message: string) {
 throw new Error(message);
 });
 });

 describe("CertificateError with real Logger", () => {
 it("should be backward compatible with existing mock logger", () => {
 // Verify our Logger class implements the Logger interface used by error.ts
 const { mockOutputChannel, logger: realLogger } =
 createMockOutputChannelWithLogger();

 // Verify the Logger has the required writeToCoderOutputChannel method
 expect(typeof realLogger.writeToCoderOutputChannel).toBe("function");

 // Verify it works like the mock logger
 realLogger.writeToCoderOutputChannel("Test message");
 expect(mockOutputChannel.appendLine).toHaveBeenCalledWith(
 expect.stringMatching(/\[.*\] \[INFO\] Test message/),
 );
 });

 it("should work with our Logger implementation", async () => {
 // Create a real Logger instance with mock output channel
 const { mockOutputChannel, logger: realLogger } =
 createMockOutputChannelWithLogger();

 // Mock CertificateError.determineVerifyErrorCause to throw an error
 const originalDetermine = CertificateError.determineVerifyErrorCause;
 CertificateError.determineVerifyErrorCause = vi
 .fn()
 .mockRejectedValue(new Error("Failed to parse certificate"));

 const axiosError = {
 isAxiosError: true,
 code: X509_ERR_CODE.UNABLE_TO_VERIFY_LEAF_SIGNATURE,
 message: "unable to verify leaf signature",
 };

 // Test that maybeWrap works with our real Logger
 const result = await CertificateError.maybeWrap(
 axiosError,
 "https://test.com",
 realLogger,
 );

 // Should return original error when determineVerifyErrorCause fails
 expect(result).toBe(axiosError);

 // Verify the message was logged through our Logger
 expect(mockOutputChannel.appendLine).toHaveBeenCalledWith(
 expect.stringMatching(
 /\[.*\] \[INFO\] Failed to parse certificate from https:\/\/test.com/,
 ),
 );

 // Verify the log was stored in the Logger
 const logs = realLogger.getLogs();
 expect(logs).toHaveLength(1);
 expect(logs[0].level).toBe("INFO");
 expect(logs[0].message).toContain(
 "Failed to parse certificate from https://test.com",
 );

 // Restore original method
 CertificateError.determineVerifyErrorCause = originalDetermine;
 });

 it("should log successful certificate wrapping with real Logger", async () => {
 const { logger: realLogger } = createMockOutputChannelWithLogger();
 const address = await startServer("chain");

 const request = axios.get(address);
 await expect(request).rejects.toHaveProperty(
 "code",
 X509_ERR_CODE.SELF_SIGNED_CERT_IN_CHAIN,
 );

 try {
 await request;
 } catch (error) {
 // Clear any existing logs
 realLogger.clear();

 const wrapped = await CertificateError.maybeWrap(
 error,
 address,
 realLogger,
 );
 expect(wrapped instanceof CertificateError).toBeTruthy();
 expect((wrapped as CertificateError).x509Err).toBe(
 X509_ERR.UNTRUSTED_CHAIN,
 );

 // Since the certificate error was successfully wrapped, no error should be logged
 const logs = realLogger.getLogs();
 expect(logs).toHaveLength(0);
 }
 });
 });

 describe("CertificateError instance methods", () => {
 it("should update configuration and show message when allowInsecure is called", async () => {
 const vscode = await import("vscode");
diff --git a/src/logger.test.ts b/src/logger.test.ts
 import { describe, it, expect, beforeEach, vi } from "vitest";
 import { Logger, LoggerService } from "./logger";
 import { createMockOutputChannelWithLogger } from "./test-helpers";

 describe("Logger", () => {
 let logger: Logger;
 let mockOutputChannel: {
 appendLine: ReturnType<typeof vi.fn>;
 };

 beforeEach(() => {
 logger = new Logger();
 mockOutputChannel = {
 appendLine: vi.fn(),
 };
 logger = new Logger(mockOutputChannel);
 });

 it("should log error messages", () => {

 describe("Logger with OutputChannel", () => {
 it("should write logs to output channel when provided", () => {
 const mockOutputChannel = {
 appendLine: vi.fn(),
 };

 const logger = new Logger(mockOutputChannel);
 const { mockOutputChannel, logger } = createMockOutputChannelWithLogger();
 logger.info("Test message");

 expect(mockOutputChannel.appendLine).toHaveBeenCalledOnce();
 expect(mockOutputChannel.appendLine).toHaveBeenCalledWith(
 expect.stringContaining("[INFO] Test message"),
 );
 });

 it("should implement writeToCoderOutputChannel for backward compatibility", () => {
 const { mockOutputChannel, logger } = createMockOutputChannelWithLogger();

 logger.writeToCoderOutputChannel("Test message");

 expect(mockOutputChannel.appendLine).toHaveBeenCalledWith(
 expect.stringMatching(/\[.*\] \[INFO\] Test message/),
 );
 });

 it("should log writeToCoderOutputChannel messages as INFO level", () => {
 const logger = new Logger();

 logger.writeToCoderOutputChannel("Backward compatible message");

 const logs = logger.getLogs();
 expect(logs).toHaveLength(1);
 expect(logs[0].level).toBe("INFO");
 expect(logs[0].message).toBe("Backward compatible message");
 });

 it("should handle error-like messages appropriately", () => {
 const { mockOutputChannel, logger } = createMockOutputChannelWithLogger();

 logger.writeToCoderOutputChannel("Error: Something went wrong");

 expect(mockOutputChannel.appendLine).toHaveBeenCalledWith(
 expect.stringMatching(/\[.*\] \[INFO\] Error: Something went wrong/),
 );
 });
 });

 describe("Logger with log level filtering", () => {
 it("should filter debug logs when verbose is false", () => {
 const mockOutputChannel = {
 appendLine: vi.fn(),
 };

 const logger = new Logger(mockOutputChannel, { verbose: false });
 const { mockOutputChannel, logger } = createMockOutputChannelWithLogger({
 verbose: false,
 });
 logger.debug("Debug message");
 logger.info("Info message");
 logger.warn("Warn message");
 });

 it("should include debug logs when verbose is true", () => {
 const mockOutputChannel = {
 appendLine: vi.fn(),
 };

 const logger = new Logger(mockOutputChannel, { verbose: true });
 logger.debug("Debug message");
 logger.info("Info message");
 const { mockOutputChannel, logger: verboseLogger } =
 createMockOutputChannelWithLogger({ verbose: true });
 verboseLogger.debug("Debug message");
 verboseLogger.info("Info message");

 expect(mockOutputChannel.appendLine).toHaveBeenCalledTimes(2);
 expect(mockOutputChannel.appendLine).toHaveBeenCalledWith(
 });

 it("should include data in output when provided", () => {
 const mockOutputChannel = {
 appendLine: vi.fn(),
 };

 const logger = new Logger(mockOutputChannel);
 const { mockOutputChannel, logger } = createMockOutputChannelWithLogger();
 const data = { userId: 123, action: "login" };
 logger.info("User action", data);

diff --git a/src/logger.ts b/src/logger.ts
 this.outputChannel.appendLine(message);
 }
 }

 /**
 * Backward compatibility method for existing code using writeToCoderOutputChannel
 * Logs messages at INFO level
 */
 writeToCoderOutputChannel(message: string): void {
 this.info(message);
 }
 }

 export interface WorkspaceConfiguration {
diff --git a/src/test-helpers.ts b/src/test-helpers.ts
 } from "coder/site/src/api/typesGenerated";
 import { vi } from "vitest";
 import type * as vscode from "vscode";
 import { Logger } from "./logger";
 import type { Storage } from "./storage";

 /**
 };
 }

 /**
 * Create a mock output channel and Logger instance for testing
 * Returns both the mock output channel and a real Logger instance
 */
 export function createMockOutputChannelWithLogger(options?: {
 verbose?: boolean;
 }): {
 mockOutputChannel: {
 appendLine: ReturnType<typeof vi.fn>;
 };
 logger: Logger;
 } {
 const mockOutputChannel = {
 appendLine: vi.fn(),
 };
 const logger = new Logger(mockOutputChannel, options);
 return { mockOutputChannel, logger };
 }

 /**
 * Create a partial mock Storage with only the methods needed
 */
 getHeaders: ReturnType<typeof vi.fn>;
 writeToCoderOutputChannel: ReturnType<typeof vi.fn>;
 }> = {},
 ):Partial<Storage> {
 ): Storage {
 return {
 getHeaders: overrides.getHeaders ?? vi.fn().mockResolvedValue({}),
 writeToCoderOutputChannel: overrides.writeToCoderOutputChannel ?? vi.fn(),
 ...overrides,
 };
 } as unknown as Storage;
 }
Original file line number	Diff line number	Diff line change
Expand Up		@@ -9,6 +9,7 @@ import {
		X509_ERR_CODE,
		getErrorDetail,
		} from "./error";
		import { createMockOutputChannelWithLogger } from "./test-helpers";

		// Before each test we make a request to sanity check that we really get the
		// error we are expecting, then we run it through CertificateError.
Expand DownExpand Up		@@ -58,6 +59,7 @@ vi.mock("coder/site/src/api/errors", () => ({
		}),
		}));

		// Use a mock logger that throws on error messages to ensure tests fail if unexpected logs occur
		const logger = {
		writeToCoderOutputChannel(message: string) {
		throw new Error(message);
Expand DownExpand Up		@@ -387,6 +389,101 @@ describe("CertificateError.maybeWrap error handling", () => {
		});
		});

		describe("CertificateError with real Logger", () => {
		it("should be backward compatible with existing mock logger", () => {
		// Verify our Logger class implements the Logger interface used by error.ts
		const { mockOutputChannel, logger: realLogger } =
		createMockOutputChannelWithLogger();

		// Verify the Logger has the required writeToCoderOutputChannel method
		expect(typeof realLogger.writeToCoderOutputChannel).toBe("function");

		// Verify it works like the mock logger
		realLogger.writeToCoderOutputChannel("Test message");
		expect(mockOutputChannel.appendLine).toHaveBeenCalledWith(
		expect.stringMatching(/\[.*\] \[INFO\] Test message/),
		);
		});

		it("should work with our Logger implementation", async () => {
		// Create a real Logger instance with mock output channel
		const { mockOutputChannel, logger: realLogger } =
		createMockOutputChannelWithLogger();

		// Mock CertificateError.determineVerifyErrorCause to throw an error
		const originalDetermine = CertificateError.determineVerifyErrorCause;
		CertificateError.determineVerifyErrorCause = vi
		.fn()
		.mockRejectedValue(new Error("Failed to parse certificate"));

		const axiosError = {
		isAxiosError: true,
		code: X509_ERR_CODE.UNABLE_TO_VERIFY_LEAF_SIGNATURE,
		message: "unable to verify leaf signature",
		};

		// Test that maybeWrap works with our real Logger
		const result = await CertificateError.maybeWrap(
		axiosError,
		"https://test.com",
		realLogger,
		);

		// Should return original error when determineVerifyErrorCause fails
		expect(result).toBe(axiosError);

		// Verify the message was logged through our Logger
		expect(mockOutputChannel.appendLine).toHaveBeenCalledWith(
		expect.stringMatching(
		/\[.*\] \[INFO\] Failed to parse certificate from https:\/\/test.com/,
		),
		);

		// Verify the log was stored in the Logger
		const logs = realLogger.getLogs();
		expect(logs).toHaveLength(1);
		expect(logs[0].level).toBe("INFO");
		expect(logs[0].message).toContain(
		"Failed to parse certificate from https://test.com",
		);

		// Restore original method
		CertificateError.determineVerifyErrorCause = originalDetermine;
		});

		it("should log successful certificate wrapping with real Logger", async () => {
		const { logger: realLogger } = createMockOutputChannelWithLogger();
		const address = await startServer("chain");

		const request = axios.get(address);
		await expect(request).rejects.toHaveProperty(
		"code",
		X509_ERR_CODE.SELF_SIGNED_CERT_IN_CHAIN,
		);

		try {
		await request;
		} catch (error) {
		// Clear any existing logs
		realLogger.clear();

		const wrapped = await CertificateError.maybeWrap(
		error,
		address,
		realLogger,
		);
		expect(wrapped instanceof CertificateError).toBeTruthy();
		expect((wrapped as CertificateError).x509Err).toBe(
		X509_ERR.UNTRUSTED_CHAIN,
		);

		// Since the certificate error was successfully wrapped, no error should be logged
		const logs = realLogger.getLogs();
		expect(logs).toHaveLength(0);
		}
		});
		});

		describe("CertificateError instance methods", () => {
		it("should update configuration and show message when allowInsecure is called", async () => {
		const vscode = await import("vscode");
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -1,11 +1,18 @@
		import { describe, it, expect, beforeEach, vi } from "vitest";
		import { Logger, LoggerService } from "./logger";
		import { createMockOutputChannelWithLogger } from "./test-helpers";

		describe("Logger", () => {
		let logger: Logger;
		let mockOutputChannel: {
		appendLine: ReturnType<typeof vi.fn>;
		};

		beforeEach(() => {
		logger = new Logger();
		mockOutputChannel = {
		appendLine: vi.fn(),
		};
		logger = new Logger(mockOutputChannel);
		});

		it("should log error messages", () => {
Expand DownExpand Up		@@ -80,27 +87,52 @@ describe("Logger", () => {

		describe("Logger with OutputChannel", () => {
		it("should write logs to output channel when provided", () => {
		const mockOutputChannel = {
		appendLine: vi.fn(),
		};

		const logger = new Logger(mockOutputChannel);
		const { mockOutputChannel, logger } = createMockOutputChannelWithLogger();
		logger.info("Test message");

		expect(mockOutputChannel.appendLine).toHaveBeenCalledOnce();
		expect(mockOutputChannel.appendLine).toHaveBeenCalledWith(
		expect.stringContaining("[INFO] Test message"),
		);
		});

		it("should implement writeToCoderOutputChannel for backward compatibility", () => {
		const { mockOutputChannel, logger } = createMockOutputChannelWithLogger();

		logger.writeToCoderOutputChannel("Test message");

		expect(mockOutputChannel.appendLine).toHaveBeenCalledWith(
		expect.stringMatching(/\[.*\] \[INFO\] Test message/),
		);
		});

		it("should log writeToCoderOutputChannel messages as INFO level", () => {
		const logger = new Logger();

		logger.writeToCoderOutputChannel("Backward compatible message");

		const logs = logger.getLogs();
		expect(logs).toHaveLength(1);
		expect(logs[0].level).toBe("INFO");
		expect(logs[0].message).toBe("Backward compatible message");
		});

		it("should handle error-like messages appropriately", () => {
		const { mockOutputChannel, logger } = createMockOutputChannelWithLogger();

		logger.writeToCoderOutputChannel("Error: Something went wrong");

		expect(mockOutputChannel.appendLine).toHaveBeenCalledWith(
		expect.stringMatching(/\[.*\] \[INFO\] Error: Something went wrong/),
		);
		});
		});

		describe("Logger with log level filtering", () => {
		it("should filter debug logs when verbose is false", () => {
		const mockOutputChannel = {
		appendLine: vi.fn(),
		};

		const logger = new Logger(mockOutputChannel, { verbose: false });
		const { mockOutputChannel, logger } = createMockOutputChannelWithLogger({
		verbose: false,
		});
		logger.debug("Debug message");
		logger.info("Info message");
		logger.warn("Warn message");
Expand All		@@ -113,13 +145,10 @@ describe("Logger with log level filtering", () => {
		});

		it("should include debug logs when verbose is true", () => {
		const mockOutputChannel = {
		appendLine: vi.fn(),
		};

		const logger = new Logger(mockOutputChannel, { verbose: true });
		logger.debug("Debug message");
		logger.info("Info message");
		const { mockOutputChannel, logger: verboseLogger } =
		createMockOutputChannelWithLogger({ verbose: true });
		verboseLogger.debug("Debug message");
		verboseLogger.info("Info message");

		expect(mockOutputChannel.appendLine).toHaveBeenCalledTimes(2);
		expect(mockOutputChannel.appendLine).toHaveBeenCalledWith(
Expand All		@@ -128,11 +157,7 @@ describe("Logger with log level filtering", () => {
		});

		it("should include data in output when provided", () => {
		const mockOutputChannel = {
		appendLine: vi.fn(),
		};

		const logger = new Logger(mockOutputChannel);
		const { mockOutputChannel, logger } = createMockOutputChannelWithLogger();
		const data = { userId: 123, action: "login" };
		logger.info("User action", data);

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -98,6 +98,14 @@ export class Logger {
		this.outputChannel.appendLine(message);
		}
		}

		/**
		* Backward compatibility method for existing code using writeToCoderOutputChannel
		* Logs messages at INFO level
		*/
		writeToCoderOutputChannel(message: string): void {
		this.info(message);
		}
		}

		export interface WorkspaceConfiguration {
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -4,6 +4,7 @@ import type {
		} from "coder/site/src/api/typesGenerated";
		import { vi } from "vitest";
		import type * as vscode from "vscode";
		import { Logger } from "./logger";
		import type { Storage } from "./storage";

		/**
Expand DownExpand Up		@@ -164,6 +165,25 @@ export function createMockConfiguration(
		};
		}

		/**
		* Create a mock output channel and Logger instance for testing
		* Returns both the mock output channel and a real Logger instance
		*/
		export function createMockOutputChannelWithLogger(options?: {
		verbose?: boolean;
		}): {
		mockOutputChannel: {
		appendLine: ReturnType<typeof vi.fn>;
		};
		logger: Logger;
		} {
		const mockOutputChannel = {
		appendLine: vi.fn(),
		};
		const logger = new Logger(mockOutputChannel, options);
		return { mockOutputChannel, logger };
		}

		/**
		* Create a partial mock Storage with only the methods needed
		*/
Expand All		@@ -172,10 +192,10 @@ export function createMockStorage(
		getHeaders: ReturnType<typeof vi.fn>;
		writeToCoderOutputChannel: ReturnType<typeof vi.fn>;
		}> = {},
		):Partial<Storage> {
		): Storage {
		return {
		getHeaders: overrides.getHeaders ?? vi.fn().mockResolvedValue({}),
		writeToCoderOutputChannel: overrides.writeToCoderOutputChannel ?? vi.fn(),
		...overrides,
		};
		} as unknown as Storage;
		}