@bluelibs/runner 3.4.2 → 4.0.1

package/src/__tests__/models/Logger.test.ts

@@ -1,519 +0,0 @@
-import { Logger, ILog, LogLevels } from "../../models/Logger";
-import { EventManager } from "../../models/EventManager";
-import { globalEvents } from "../../globals/globalEvents";
-
-describe("Logger", () => {
-  let logger: Logger;
-  let mockEventManager: jest.Mocked<EventManager>;
-  let originalEnv: any;
-
-  beforeEach(() => {
-    // Save original environment
-    originalEnv = { ...process.env };
-    
-    // Clear environment variables that might affect tests
-    delete process.env.RUNNER_DISABLE_LOGS;
-    delete process.env.RUNNER_LOG_LEVEL;
-    
-    mockEventManager = new EventManager() as jest.Mocked<EventManager>;
-    logger = new Logger(mockEventManager);
-  });
-
-  afterEach(() => {
-    // Restore original environment
-    process.env = originalEnv;
-  });
-
-  describe("log method", () => {
-    it("should emit a log event with correct data", async () => {
-      const testData = "Test log message";
-      const testLevel = "info";
-      mockEventManager.emit = jest.fn().mockResolvedValue(undefined);
-      mockEventManager.hasListeners = jest.fn().mockReturnValue(true);
-
-      logger.log(testLevel, testData);
-
-      // Wait for setImmediate to execute
-      await new Promise(setImmediate);
-
-      expect(mockEventManager.emit).toHaveBeenCalledWith(
-        globalEvents.log,
-        expect.objectContaining({
-          level: testLevel,
-          message: testData,
-          timestamp: expect.any(Date),
-        }),
-        "unknown"
-      );
-    });
-
-    it("should handle different log levels", async () => {
-      const levels: Array<LogLevels> = [
-        "trace",
-        "debug",
-        "info",
-        "warn",
-        "error",
-        "critical",
-      ];
-
-      mockEventManager.emit = jest.fn().mockResolvedValue(undefined);
-      mockEventManager.hasListeners = jest.fn().mockReturnValue(true);
-
-      for (const level of levels) {
-        logger.log(level, `Test ${level} message`, { source: "testSource" });
-      }
-
-      // Wait for setImmediate to execute
-      await new Promise(setImmediate);
-
-      // Check all calls were made
-      expect(mockEventManager.emit).toHaveBeenCalledTimes(levels.length);
-    });
-
-    it("should not emit events when there are no listeners", () => {
-      mockEventManager.emit = jest.fn().mockResolvedValue(undefined);
-      mockEventManager.hasListeners = jest.fn().mockReturnValue(false);
-
-      logger.log("info", "Test message");
-
-      // Should not emit events when no listeners
-      expect(mockEventManager.emit).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("print method", () => {
-    let consoleLogSpy: jest.SpyInstance;
-
-    beforeEach(() => {
-      consoleLogSpy = jest.spyOn(console, "log").mockImplementation();
-    });
-
-    afterEach(() => {
-      consoleLogSpy.mockRestore();
-    });
-
-    it("should print log messages correctly", async () => {
-      const testLog: ILog = {
-        level: "info",
-        source: "test",
-        message: "Test log message",
-        timestamp: new Date("2023-01-01T00:00:00Z"),
-      };
-
-      await logger.print(testLog);
-
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining("INFO")
-      );
-    });
-
-    it("should handle Error objects in log data", () => {
-      const testError = new Error("Test error");
-      const testLog: ILog = {
-        level: "error",
-        message: "Operation failed",
-        error: {
-          name: testError.name,
-          message: testError.message,
-          stack: testError.stack,
-        },
-        timestamp: new Date("2023-01-01T00:00:00Z"),
-      };
-
-      logger.print(testLog);
-
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining("ERROR")
-      );
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining("Error: Error")
-      );
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining("Test error")
-      );
-    });
-
-    it("should handle error objects without stack trace", () => {
-      const testLog: ILog = {
-        level: "error",
-        message: "Operation failed",
-        error: {
-          name: "CustomError",
-          message: "Something went wrong",
-        },
-        timestamp: new Date("2023-01-01T00:00:00Z"),
-      };
-
-      logger.print(testLog);
-
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining("ERROR")
-      );
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining("Error: CustomError")
-      );
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining("Something went wrong")
-      );
-    });
-
-    it("should pretty-print structured data", () => {
-      const testObject = { key: "value", nested: { foo: "bar" } };
-      const testLog: ILog = {
-        level: "debug",
-        message: "Debug info",
-        data: testObject,
-        timestamp: new Date("2023-01-01T00:00:00Z"),
-      };
-
-      logger.print(testLog);
-
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining("DEBUG")
-      );
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining('"key": "value"')
-      );
-    });
-
-    it("should handle object message by stringifying it", () => {
-      const objectMessage = { type: "user", action: "login" };
-      const testLog: ILog = {
-        level: "info",
-        message: objectMessage as any,
-        timestamp: new Date("2023-01-01T00:00:00Z"),
-      };
-
-      logger.print(testLog);
-
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining("INFO")
-      );
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining(JSON.stringify(objectMessage, null, 2))
-      );
-    });
-
-    it("should print context information when present", () => {
-      const context = { userId: "123", requestId: "abc-def" };
-      const testLog: ILog = {
-        level: "warn",
-        message: "Warning message",
-        data: context,
-        timestamp: new Date("2023-01-01T00:00:00Z"),
-      };
-
-      logger.print(testLog);
-
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining("WARN")
-      );
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining('"userId": "123"')
-      );
-    });
-
-    it("should print context from context field", () => {
-      const context = { userId: "456", feature: "login", source: "auth" };
-      const testLog: ILog = {
-        level: "info",
-        message: "User action",
-        context: context,
-        timestamp: new Date("2023-01-01T00:00:00Z"),
-      };
-
-      logger.print(testLog);
-
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining("INFO")
-      );
-      // Should show context but filter out 'source' since it's shown separately
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining("Context:")
-      );
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining('"userId": "456"')
-      );
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining('"feature": "login"')
-      );
-    });
-
-    it("should handle empty context gracefully", () => {
-      const testLog: ILog = {
-        level: "debug",
-        message: "Debug message",
-        context: {},
-        timestamp: new Date("2023-01-01T00:00:00Z"),
-      };
-
-      logger.print(testLog);
-
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining("DEBUG")
-      );
-      // Should not print context section for empty context
-      expect(consoleLogSpy).not.toHaveBeenCalledWith(
-        expect.stringContaining("Context:")
-      );
-    });
-
-    it("should handle unknown log levels gracefully", () => {
-      const testLog: ILog = {
-        level: "unknown" as any,
-        message: "Unknown level message",
-        timestamp: new Date("2023-01-01T00:00:00Z"),
-      };
-
-      logger.print(testLog);
-
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining("UNKNOWN")
-      );
-    });
-  });
-
-  describe("log level methods", () => {
-    const testLevels: Array<LogLevels> = [
-      "trace",
-      "debug",
-      "info",
-      "warn",
-      "error",
-      "critical",
-    ];
-
-    for (const level of testLevels) {
-      it(`should call log method with ${level} level`, () => {
-        const logSpy = jest.spyOn(logger, "log").mockImplementation();
-
-        logger[level]("Test log message");
-
-        expect(logSpy).toHaveBeenCalledWith(
-          level,
-          "Test log message",
-          {} // the LogInfo parameter
-        );
-      });
-    }
-  });
-
-  describe("with method", () => {
-    it("should create a new logger with additional context", () => {
-      const initialContext = { source: "initial" };
-      const loggerWithContext = new Logger(mockEventManager, initialContext);
-
-      const additionalContext = { userId: "123", feature: "auth" };
-      const newLogger = loggerWithContext.with(additionalContext);
-
-      expect(newLogger).toBeInstanceOf(Logger);
-      expect(newLogger).not.toBe(loggerWithContext);
-
-      // Test that the context is merged by checking the log call
-      const logSpy = jest.spyOn(newLogger, "log").mockImplementation();
-      newLogger.info("test message");
-
-      expect(logSpy).toHaveBeenCalledWith("info", "test message", {});
-    });
-
-    it("should override context values when keys overlap", () => {
-      const initialContext = { source: "initial", common: "old" };
-      const loggerWithContext = new Logger(mockEventManager, initialContext);
-
-      const newContext = { source: "override", newProp: "value" };
-      const newLogger = loggerWithContext.with(newContext);
-
-      // The new logger should have the overridden context
-      expect(newLogger).toBeInstanceOf(Logger);
-    });
-
-    it("should use bound context in log calls", async () => {
-      const boundContext = { source: "testSource", userId: "123" };
-      const loggerWithContext = new Logger(mockEventManager, boundContext);
-
-      mockEventManager.emit = jest.fn().mockResolvedValue(undefined);
-      mockEventManager.hasListeners = jest.fn().mockReturnValue(true);
-
-      loggerWithContext.log("info", "Test message");
-
-      await new Promise(setImmediate);
-
-      expect(mockEventManager.emit).toHaveBeenCalledWith(
-        globalEvents.log,
-        expect.objectContaining({
-          source: "testSource",
-          context: boundContext,
-        }),
-        "testSource"
-      );
-    });
-  });
-
-  describe("error handling", () => {
-    it("should handle event emission errors gracefully", async () => {
-      const consoleErrorSpy = jest.spyOn(console, "error").mockImplementation();
-      const emitError = new Error("Event emission failed");
-
-      mockEventManager.emit = jest.fn().mockRejectedValue(emitError);
-      mockEventManager.hasListeners = jest.fn().mockReturnValue(true);
-
-      logger.log("error", "Test error message");
-
-      // Wait for setImmediate and promise rejection to be handled
-      await new Promise(setImmediate);
-      await new Promise((resolve) => setTimeout(resolve, 0));
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        "Logger event emission failed:",
-        emitError
-      );
-
-      consoleErrorSpy.mockRestore();
-    });
-
-    it("should extract error information from Error objects", async () => {
-      mockEventManager.emit = jest.fn().mockResolvedValue(undefined);
-      mockEventManager.hasListeners = jest.fn().mockReturnValue(true);
-
-      const testError = new Error("Test error message");
-      testError.name = "CustomError";
-
-      logger.log("error", "Operation failed", { error: testError });
-
-      // Wait for setImmediate to execute
-      await new Promise(setImmediate);
-
-      expect(mockEventManager.emit).toHaveBeenCalledWith(
-        globalEvents.log,
-        expect.objectContaining({
-          level: "error",
-          message: "Operation failed",
-          error: {
-            name: "CustomError",
-            message: "Test error message",
-            stack: expect.any(String),
-          },
-          timestamp: expect.any(Date),
-        }),
-        "unknown"
-      );
-    });
-  });
-
-  describe("default print threshold", () => {
-    it("should default to 'info' level when no environment variables are set", () => {
-      const logger = new Logger(mockEventManager);
-      expect(logger.printThreshold).toBe("info");
-    });
-
-    it("should respect RUNNER_DISABLE_LOGS=true to disable logging", () => {
-      process.env.RUNNER_DISABLE_LOGS = "true";
-      const logger = new Logger(mockEventManager);
-      expect(logger.printThreshold).toBeNull();
-    });
-
-    it("should respect RUNNER_DISABLE_LOGS=1 to disable logging", () => {
-      process.env.RUNNER_DISABLE_LOGS = "1";
-      const logger = new Logger(mockEventManager);
-      expect(logger.printThreshold).toBeNull();
-    });
-
-    it("should respect RUNNER_LOG_LEVEL environment variable", () => {
-      process.env.RUNNER_LOG_LEVEL = "error";
-      const logger = new Logger(mockEventManager);
-      expect(logger.printThreshold).toBe("error");
-    });
-
-    it("should ignore invalid RUNNER_LOG_LEVEL and use default", () => {
-      process.env.RUNNER_LOG_LEVEL = "invalid_level";
-      const logger = new Logger(mockEventManager);
-      expect(logger.printThreshold).toBe("info");
-    });
-
-    it("should prioritize RUNNER_DISABLE_LOGS over RUNNER_LOG_LEVEL", () => {
-      process.env.RUNNER_DISABLE_LOGS = "true";
-      process.env.RUNNER_LOG_LEVEL = "debug";
-      const logger = new Logger(mockEventManager);
-      expect(logger.printThreshold).toBeNull();
-    });
-
-    it("should print info level logs by default", () => {
-      const consoleLogSpy = jest.spyOn(console, "log").mockImplementation();
-      
-      const logger = new Logger(mockEventManager);
-      logger.log("info", "This should be printed by default");
-      
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining("This should be printed by default")
-      );
-      
-      consoleLogSpy.mockRestore();
-    });
-
-    it("should not print debug level logs by default", () => {
-      const consoleLogSpy = jest.spyOn(console, "log").mockImplementation();
-      
-      const logger = new Logger(mockEventManager);
-      logger.log("debug", "This should not be printed by default");
-      
-      expect(consoleLogSpy).not.toHaveBeenCalledWith(
-        expect.stringContaining("This should not be printed by default")
-      );
-      
-      consoleLogSpy.mockRestore();
-    });
-  });
-
-  it("should auto-print logs based on autoPrintLogsAfter option", () => {
-    const autoPrintLevel: LogLevels = "warn";
-    logger.setPrintThreshold(autoPrintLevel);
-    const consoleLogSpy = jest.spyOn(console, "log").mockImplementation();
-
-    const levels: Array<LogLevels> = [
-      "trace",
-      "debug",
-      "info",
-      "warn",
-      "error",
-      "critical",
-    ];
-
-    for (const level of levels) {
-      logger.setPrintThreshold(level);
-      logger.log(level, `Test ${level} message`);
-
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining(`Test ${level} message`)
-      );
-    }
-
-    // ensure events with a higher level thatn auto print level are printed, and lower levels are not
-    logger.setPrintThreshold("error");
-    logger.log("info", "xx Test info message");
-    logger.log("error", "xx Test error message");
-
-    expect(consoleLogSpy).toHaveBeenCalledWith(
-      expect.stringContaining("xx Test error message")
-    );
-
-    expect(consoleLogSpy).not.toHaveBeenCalledWith(
-      expect.stringContaining("xx Test info message")
-    );
-
-    consoleLogSpy.mockRestore();
-  });
-
-  it("should disable auto-printing when setPrintThreshold is set to null", () => {
-    const consoleLogSpy = jest.spyOn(console, "log").mockImplementation();
-
-    // Set to null to disable auto-printing
-    logger.setPrintThreshold(null);
-
-    logger.log("error", "Should not be printed");
-
-    expect(consoleLogSpy).not.toHaveBeenCalled();
-
-    consoleLogSpy.mockRestore();
-  });
-});

package/src/__tests__/models/Queue.test.ts

@@ -1,189 +0,0 @@
-// queue.test.ts
-import { Queue } from "../.."; // <-- adjust path if needed
-
-/* ------------------------------------------------------------------ */
-/* Helpers                                                            */
-/* ------------------------------------------------------------------ */
-
-/** Flush native micro‑tasks once (Promise jobs / process.nextTick). */
-const flushMicroTasks = () => Promise.resolve();
-
-/** Small delay helper for tests */
-const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
-
-/* ------------------------------------------------------------------ */
-/* Tests                                                              */
-/* ------------------------------------------------------------------ */
-
-describe("Queue", () => {
-  it("runs tasks sequentially and returns their results in order", async () => {
-    const q = new Queue();
-
-    const started: number[] = [];
-    const finished: number[] = [];
-    let concurrent = 0;
-    let maxConcurrent = 0;
-
-    const taskFactory = (id: number) => async () => {
-      started.push(id);
-      concurrent++;
-      maxConcurrent = Math.max(maxConcurrent, concurrent);
-
-      // simulate async work with a real small delay
-      await delay(1);
-
-      finished.push(id);
-      concurrent--;
-      return id;
-    };
-
-    const p1 = q.run(taskFactory(1));
-    const p2 = q.run(taskFactory(2));
-    const p3 = q.run(taskFactory(3));
-
-    const results = await Promise.all([p1, p2, p3]);
-
-    expect(results).toEqual([1, 2, 3]);
-    expect(started).toEqual([1, 2, 3]);
-    expect(finished).toEqual([1, 2, 3]);
-    expect(maxConcurrent).toBe(1); // never overlapped
-  });
-
-  it("detects dead‑lock when a queued task enqueues another task", async () => {
-    const q = new Queue();
-
-    const deadlock = () => q.run(async () => "nested"); // <-- illegal
-
-    await expect(q.run(deadlock)).rejects.toThrow(/Dead‑lock/);
-  });
-
-  it("dispose() drains pending tasks and rejects new ones", async () => {
-    const q = new Queue();
-
-    const task = async () => {
-      await delay(1);
-      return "ok";
-    };
-
-    const p1 = q.run(task);
-    const p2 = q.run(task);
-
-    const disposeDone = q.dispose(); // default => { cancel: false }
-
-    await expect(disposeDone).resolves.toBeUndefined();
-    await expect(p1).resolves.toBe("ok");
-    await expect(p2).resolves.toBe("ok");
-
-    await expect(q.run(task)).rejects.toThrow(/disposed/);
-  });
-
-  it("dispose({ cancel: true }) aborts the running task", async () => {
-    jest.useFakeTimers();
-
-    const q = new Queue();
-
-    /** Long‑running task that cooperates with AbortSignal. */
-    const longTask = async (signal: AbortSignal) =>
-      new Promise<void>((_res, rej) => {
-        const tid = setTimeout(_res, 100); // never actually fires
-        signal.addEventListener("abort", () => {
-          clearTimeout(tid);
-          rej(new Error("aborted"));
-        });
-      });
-
-    const p = q.run(longTask);
-
-    // Let the task start
-    jest.advanceTimersByTime(0);
-    await flushMicroTasks();
-
-    const disposeDone = q.dispose({ cancel: true });
-
-    await flushMicroTasks(); // allow rejection to propagate
-
-    await expect(p).rejects.toThrow(/aborted/);
-    await expect(disposeDone).resolves.toBeUndefined();
-
-    jest.useRealTimers();
-  });
-
-  it("dispose() is idempotent - multiple calls should be safe", async () => {
-    const q = new Queue();
-
-    const task = async () => {
-      await delay(1);
-      return "ok";
-    };
-
-    const p = q.run(task);
-
-    // First dispose call
-    const dispose1 = q.dispose();
-    // Second dispose call should return immediately (if (this.disposed) return;)
-    const dispose2 = q.dispose();
-    // Third dispose call should also return immediately
-    const dispose3 = q.dispose();
-
-    await expect(dispose1).resolves.toBeUndefined();
-    await expect(dispose2).resolves.toBeUndefined();
-    await expect(dispose3).resolves.toBeUndefined();
-    await expect(p).resolves.toBe("ok");
-
-    // Further dispose calls after everything is settled should also be safe
-    const dispose4 = q.dispose();
-    await expect(dispose4).resolves.toBeUndefined();
-  });
-
-  it("dispose() properly handles rejected tail promises", async () => {
-    const q = new Queue();
-
-    // Run a task first to establish the normal tail chain
-    await q.run(async () => "setup");
-
-    // Directly set the tail to a promise that will reject
-    // This simulates an internal error scenario where the tail becomes rejected
-    const rejectingPromise = Promise.reject(
-      new Error("Simulated tail rejection")
-    );
-    (q as any).tail = rejectingPromise;
-
-    // Spy on the rejecting promise to verify the catch is called
-    const catchSpy = jest.spyOn(rejectingPromise, "catch");
-
-    // The dispose method should handle this rejection with: await this.tail.catch(() => {})
-    // This specifically tests the line: await this.tail.catch(() => {});
-    await expect(q.dispose()).resolves.toBeUndefined();
-
-    // Verify that the catch method was called (meaning the tail.catch() line was executed)
-    expect(catchSpy).toHaveBeenCalledWith(expect.any(Function));
-
-    // Verify the queue is properly disposed
-    await expect(q.run(async () => "test")).rejects.toThrow(/disposed/);
-  });
-
-  it("should propagate task exceptions to the caller", async () => {
-    const q = new Queue();
-
-    // Test that exceptions are propagated, not swallowed
-    const errorTask = async () => {
-      await delay(1);
-      throw new Error("Task exception");
-    };
-
-    const successTask = async () => {
-      await delay(1);
-      return "success";
-    };
-
-    // Exception should be catchable by the caller
-    await expect(q.run(errorTask)).rejects.toThrow("Task exception");
-
-    // Queue should still work for subsequent tasks
-    await expect(q.run(successTask)).resolves.toBe("success");
-
-    // Multiple exceptions should all be catchable
-    await expect(q.run(errorTask)).rejects.toThrow("Task exception");
-    await expect(q.run(errorTask)).rejects.toThrow("Task exception");
-  });
-});