Add logger tests

Author: markkohdev

src/extension/logger.ts

@@ -27,7 +27,7 @@ export function initializeLogger(context: vscode.ExtensionContext): void {
     return; // Already initialized
   }
 
-  logger = vscode.window.createOutputChannel("Bazel", { log: true });
+  logger = vscode.window.createOutputChannel("Bazel VSCode", { log: true });
   context.subscriptions.push(logger);
 }
 
@@ -40,7 +40,8 @@ export function initializeLogger(context: vscode.ExtensionContext): void {
 function getLogger(): vscode.LogOutputChannel {
   if (!logger) {
     throw new Error(
-      "Logger not initialized. Call initializeLogger() during extension activation.",
+      "Logger not initialized. Call initializeLogger() during extension \
+      activation.",
     );
   }
   return logger;

test/logger.test.ts

@@ -0,0 +1,124 @@
+// Copyright 2018 The Bazel Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import assert = require("assert");
+import * as vscode from "vscode";
+import {
+  initializeLogger,
+  trace,
+  debug,
+  info,
+  warn,
+  error,
+} from "../src/extension/logger";
+
+describe("The logger module", () => {
+  let mockContext: vscode.ExtensionContext;
+  let disposables: vscode.Disposable[] = [];
+
+  beforeEach(() => {
+    // Create a mock extension context
+    mockContext = {
+      subscriptions: disposables,
+    } as vscode.ExtensionContext;
+  });
+
+  afterEach(() => {
+    // Clean up disposables
+    for (const disposable of disposables) {
+      disposable.dispose();
+    }
+    disposables = [];
+  });
+
+  describe("initializeLogger", () => {
+    it("can be called without throwing", () => {
+      assert.doesNotThrow(() => {
+        initializeLogger(mockContext);
+      });
+    });
+
+    it("is idempotent - does not create multiple loggers", () => {
+      // Call initializeLogger multiple times - it should be safe
+      initializeLogger(mockContext);
+      const initialLength = disposables.length;
+      initializeLogger(mockContext);
+      // Note: In the test environment, the logger may already be initialized
+      // by extension activation, so we just verify it doesn't throw
+      assert.doesNotThrow(() => {
+        initializeLogger(mockContext);
+      });
+    });
+  });
+
+  describe("logging functions", () => {
+    beforeEach(() => {
+      initializeLogger(mockContext);
+    });
+
+    it("trace logs a message", () => {
+      assert.doesNotThrow(() => {
+        trace("test trace message");
+      });
+    });
+
+    it("debug logs a message", () => {
+      assert.doesNotThrow(() => {
+        debug("test debug message");
+      });
+    });
+
+    it("info logs a message", () => {
+      assert.doesNotThrow(() => {
+        info("test info message");
+      });
+    });
+
+    it("warn logs a message", () => {
+      assert.doesNotThrow(() => {
+        warn("test warn message");
+      });
+    });
+
+    it("error logs a string message", () => {
+      assert.doesNotThrow(() => {
+        error("test error message");
+      });
+    });
+
+    it("error logs an Error object", () => {
+      assert.doesNotThrow(() => {
+        const err = new Error("test error");
+        error(err);
+      });
+    });
+
+    it("error logs an Error object with additional args", () => {
+      assert.doesNotThrow(() => {
+        const err = new Error("test error");
+        error(err, "additional", "args");
+      });
+    });
+
+    it("logging functions accept additional arguments", () => {
+      assert.doesNotThrow(() => {
+        trace("message", "arg1", 123, { key: "value" });
+        debug("message", "arg1", 123, { key: "value" });
+        info("message", "arg1", 123, { key: "value" });
+        warn("message", "arg1", 123, { key: "value" });
+        error("message", "arg1", 123, { key: "value" });
+      });
+    });
+  });
+});