Add logger tests

Author: mayank1513

lib/src/logger.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import fs from "fs";
+import path from "path";
+import { createLogger } from "./logger";
+
+const TEST_LOG_DIR = "test-logs";
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  if (fs.existsSync(TEST_LOG_DIR)) {
+    fs.rmSync(TEST_LOG_DIR, { recursive: true, force: true });
+  }
+});
+
+afterEach(() => {
+  if (fs.existsSync(TEST_LOG_DIR)) {
+    fs.rmSync(TEST_LOG_DIR, { recursive: true, force: true });
+  }
+});
+
+describe("createLogger", () => {
+  it("creates logger with default config", () => {
+    const logger = createLogger();
+    expect(logger).toHaveProperty("info");
+    expect(logger).toHaveProperty("warn");
+    expect(logger).toHaveProperty("error");
+    expect(logger).toHaveProperty("debug");
+    expect(logger).toHaveProperty("flush");
+  });
+
+  it("logs to console for stdout levels", () => {
+    const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    
+    const logger = createLogger({ levels: { stdout: ["warn", "error"] } });
+    
+    logger.warn("test", "warning message");
+    logger.error("test", "error message");
+    logger.info("test", "info message");
+    
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("[WARN] warning message"));
+    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining("[ERROR] error message"));
+    expect(consoleSpy).not.toHaveBeenCalledWith(expect.stringContaining("[INFO] info message"));
+  });
+
+  it("writes to files in memory mode", () => {
+    const logger = createLogger({ 
+      mode: "memory", 
+      logDir: TEST_LOG_DIR,
+      levels: { file: ["info", "warn"] }
+    });
+    
+    logger.info("test", "info message");
+    logger.warn("test", "warning message");
+    logger.flush();
+    
+    const files = fs.readdirSync(TEST_LOG_DIR);
+    expect(files.length).toBeGreaterThan(0);
+    
+    const logContent = fs.readFileSync(path.join(TEST_LOG_DIR, files[0]), "utf8");
+    expect(logContent).toContain("[INFO] info message");
+    expect(logContent).toContain("[WARN] warning message");
+  });
+
+  it("writes to single file when singleFile is true", () => {
+    const logger = createLogger({ 
+      mode: "memory", 
+      logDir: TEST_LOG_DIR,
+      singleFile: true
+    });
+    
+    logger.info("file1", "message1");
+    logger.info("file2", "message2");
+    logger.flush();
+    
+    const files = fs.readdirSync(TEST_LOG_DIR);
+    expect(files.length).toBe(1);
+    expect(files[0]).toMatch(/combined-/);
+  });
+
+  it("creates log directory if it doesn't exist", () => {
+    const logger = createLogger({ logDir: TEST_LOG_DIR });
+    expect(fs.existsSync(TEST_LOG_DIR)).toBe(true);
+  });
+
+  it("handles stream mode", async () => {
+    const logger = createLogger({ 
+      mode: "stream", 
+      logDir: TEST_LOG_DIR 
+    });
+    
+    logger.info("test", "stream message");
+    logger.flush();
+    
+    // Wait for stream to close
+    await new Promise(resolve => setTimeout(resolve, 10));
+    
+    const files = fs.readdirSync(TEST_LOG_DIR);
+    expect(files.length).toBeGreaterThan(0);
+  });
+
+  it("filters logs by level", () => {
+    const logger = createLogger({ 
+      mode: "memory",
+      logDir: TEST_LOG_DIR,
+      levels: { file: ["error"] }
+    });
+    
+    logger.info("test", "info");
+    logger.error("test", "error");
+    logger.flush();
+    
+    const files = fs.readdirSync(TEST_LOG_DIR);
+    const content = fs.readFileSync(path.join(TEST_LOG_DIR, files[0]), "utf8");
+    expect(content).toContain("error");
+    expect(content).not.toContain("info");
+  });
+});

lib/src/matcher.test.ts

@@ -64,11 +64,6 @@ for (const matcherName of ["basicMatcher", "micromatch", "picomatch"] as const)
       expect(matcher.isMatch("test/app.ts", ["!**/*.test.ts"])).toBe(true);
     });
 
-    // it("positive includes everything, negative excludes subset", () => {
-    //   expect(matcher.isMatch("src/index.ts", ["**", "!src/**"])).toBe(false); // excluded
-    //   expect(matcher.isMatch("lib/app.ts", ["**", "!src/**"])).toBe(true); // included
-    // });
-
     it("root level negation", () => {
       expect(matcher.isMatch("src", ["!src"])).toBe(false);
       expect(matcher.isMatch("other", ["!src"])).toBe(true);