Function mockLogger

Returns {
    restore: () => void;
    reset: () => void;
    clear: () => void;
    logger: {
        info: Mock<any, any, any>;
        warn: Mock<any, any, any>;
        error: Mock<any, any, any>;
        debug: Mock<any, any, any>;
        verbose: Mock<any, any, any>;
        silly: Mock<any, any, any>;
        log: Mock<any, any, any>;
    };
    mocks: {
        info: Mock<any, any, any>;
        warn: Mock<any, any, any>;
        error: Mock<any, any, any>;
        debug: Mock<any, any, any>;
        verbose: Mock<any, any, any>;
        silly: Mock<any, any, any>;
    };
    helpers: {
        expectLogCall: (
            level: "error" | "warn" | "info" | "debug" | "verbose" | "silly",
            message: string,
            meta?: any,
        ) => void;
        expectLogCallCount: (
            level: "error" | "warn" | "info" | "debug" | "verbose" | "silly",
            times: number,
        ) => void;
        expectLogNotCalled: (
            level: "error" | "warn" | "info" | "debug" | "verbose" | "silly",
        ) => void;
        expectInfo: (message: string, meta?: any) => void;
        expectWarn: (message: string, meta?: any) => void;
        expectError: (message: string, meta?: any) => void;
        expectDebug: (message: string, meta?: any) => void;
        expectLogContaining: (text: string) => void;
        expectErrorWithException: (
            errorMessage?: string,
            errorType?: new (...args: any[]) => Error,
        ) => void;
        getLogCalls: (
            level: "error" | "warn" | "info" | "debug" | "verbose" | "silly",
        ) => any[];
        getAllLogCalls: () => {
            info: any[];
            warn: any[];
            error: any[];
            debug: any[];
            verbose: any[];
            silly: any[];
        };
        expectNoLogs: () => void;
        expectLogOrder: (
            expectedCalls: {
                level: "error" | "warn" | "info" | "debug" | "verbose" | "silly";
                message: string;
                meta?: any;
            }[],
        ) => void;
        spyOnConsole: () => {
            log: SpyInstance<void, [message?: any, ...optionalParams: any[]], any>;
            warn: SpyInstance<void, [message?: any, ...optionalParams: any[]], any>;
            error: SpyInstance<void, [message?: any, ...optionalParams: any[]], any>;
            info: SpyInstance<void, [message?: any, ...optionalParams: any[]], any>;
            debug: SpyInstance<void, [message?: any, ...optionalParams: any[]], any>;
            restore: () => void;
            reset: () => void;
        };
    };
    scenarios: {
        captureAll: () => {
            info: Mock<any, any, any>;
            warn: Mock<any, any, any>;
            error: Mock<any, any, any>;
            debug: Mock<any, any, any>;
            verbose: Mock<any, any, any>;
            silly: Mock<any, any, any>;
            log: Mock<any, any, any>;
        };
        throwOnError: () => void;
        silent: () => {
            info: Mock<any, any, any>;
            warn: Mock<any, any, any>;
            error: Mock<any, any, any>;
            debug: Mock<any, any, any>;
            verbose: Mock<any, any, any>;
            silly: Mock<any, any, any>;
            log: Mock<any, any, any>;
        };
        custom: (
            implementations: Partial<
                {
                    info: (...args: any[]) => any;
                    warn: (...args: any[]) => any;
                    error: (...args: any[]) => any;
                    debug: (...args: any[]) => any;
                    verbose: (...args: any[]) => any;
                    silly: (...args: any[]) => any;
                },
            >,
        ) => void;
    };
}

• restore: () => void

  Restore the original logger module

• reset: () => void

  Reset all logger mocks

• clear: () => void

  Clear all logger mock call history

• logger: {
      info: Mock<any, any, any>;
      warn: Mock<any, any, any>;
      error: Mock<any, any, any>;
      debug: Mock<any, any, any>;
      verbose: Mock<any, any, any>;
      silly: Mock<any, any, any>;
      log: Mock<any, any, any>;
  }

  Access to the mock logger instance

• mocks: {
      info: Mock<any, any, any>;
      warn: Mock<any, any, any>;
      error: Mock<any, any, any>;
      debug: Mock<any, any, any>;
      verbose: Mock<any, any, any>;
      silly: Mock<any, any, any>;
  }

  Access to individual mock functions

• helpers: {
      expectLogCall: (
          level: "error" | "warn" | "info" | "debug" | "verbose" | "silly",
          message: string,
          meta?: any,
      ) => void;
      expectLogCallCount: (
          level: "error" | "warn" | "info" | "debug" | "verbose" | "silly",
          times: number,
      ) => void;
      expectLogNotCalled: (
          level: "error" | "warn" | "info" | "debug" | "verbose" | "silly",
      ) => void;
      expectInfo: (message: string, meta?: any) => void;
      expectWarn: (message: string, meta?: any) => void;
      expectError: (message: string, meta?: any) => void;
      expectDebug: (message: string, meta?: any) => void;
      expectLogContaining: (text: string) => void;
      expectErrorWithException: (
          errorMessage?: string,
          errorType?: new (...args: any[]) => Error,
      ) => void;
      getLogCalls: (
          level: "error" | "warn" | "info" | "debug" | "verbose" | "silly",
      ) => any[];
      getAllLogCalls: () => {
          info: any[];
          warn: any[];
          error: any[];
          debug: any[];
          verbose: any[];
          silly: any[];
      };
      expectNoLogs: () => void;
      expectLogOrder: (
          expectedCalls: {
              level: "error" | "warn" | "info" | "debug" | "verbose" | "silly";
              message: string;
              meta?: any;
          }[],
      ) => void;
      spyOnConsole: () => {
          log: SpyInstance<void, [message?: any, ...optionalParams: any[]], any>;
          warn: SpyInstance<void, [message?: any, ...optionalParams: any[]], any>;
          error: SpyInstance<void, [message?: any, ...optionalParams: any[]], any>;
          info: SpyInstance<void, [message?: any, ...optionalParams: any[]], any>;
          debug: SpyInstance<void, [message?: any, ...optionalParams: any[]], any>;
          restore: () => void;
          reset: () => void;
      };
  }

  Helper methods for verifying log messages

  • expectLogCall: (
        level: "error" | "warn" | "info" | "debug" | "verbose" | "silly",
        message: string,
        meta?: any,
    ) => void

    Verify that a specific log level was called with a message

  • expectLogCallCount: (
        level: "error" | "warn" | "info" | "debug" | "verbose" | "silly",
        times: number,
    ) => void

    Verify that a specific log level was called a certain number of times

  • expectLogNotCalled: (level: "error" | "warn" | "info" | "debug" | "verbose" | "silly") => void

    Verify that a specific log level was not called

  • expectInfo: (message: string, meta?: any) => void

    Verify that info log was called with specific message

  • expectWarn: (message: string, meta?: any) => void

    Verify that warn log was called with specific message

  • expectError: (message: string, meta?: any) => void

    Verify that error log was called with specific message

  • expectDebug: (message: string, meta?: any) => void

    Verify that debug log was called with specific message

  • expectLogContaining: (text: string) => void

    Verify that any log level was called with a message containing specific text

  • expectErrorWithException: (errorMessage?: string, errorType?: new (...args: any[]) => Error) => void

    Verify that error log was called with an Error object

  • getLogCalls: (level: "error" | "warn" | "info" | "debug" | "verbose" | "silly") => any[]

    Get all log calls for a specific level

  • getAllLogCalls: () => {
        info: any[];
        warn: any[];
        error: any[];
        debug: any[];
        verbose: any[];
        silly: any[];
    }

    Get all log calls across all levels

  • expectNoLogs: () => void

    Verify that no logs were called at any level

  • expectLogOrder: (
        expectedCalls: {
            level: "error" | "warn" | "info" | "debug" | "verbose" | "silly";
            message: string;
            meta?: any;
        }[],
    ) => void

    Verify that logs were called in a specific order

  • spyOnConsole: () => {
        log: SpyInstance<void, [message?: any, ...optionalParams: any[]], any>;
        warn: SpyInstance<void, [message?: any, ...optionalParams: any[]], any>;
        error: SpyInstance<void, [message?: any, ...optionalParams: any[]], any>;
        info: SpyInstance<void, [message?: any, ...optionalParams: any[]], any>;
        debug: SpyInstance<void, [message?: any, ...optionalParams: any[]], any>;
        restore: () => void;
        reset: () => void;
    }

    Create a spy on console methods (useful for testing console.log, etc.)

• scenarios: {
      captureAll: () => {
          info: Mock<any, any, any>;
          warn: Mock<any, any, any>;
          error: Mock<any, any, any>;
          debug: Mock<any, any, any>;
          verbose: Mock<any, any, any>;
          silly: Mock<any, any, any>;
          log: Mock<any, any, any>;
      };
      throwOnError: () => void;
      silent: () => {
          info: Mock<any, any, any>;
          warn: Mock<any, any, any>;
          error: Mock<any, any, any>;
          debug: Mock<any, any, any>;
          verbose: Mock<any, any, any>;
          silly: Mock<any, any, any>;
          log: Mock<any, any, any>;
      };
      custom: (
          implementations: Partial<
              {
                  info: (...args: any[]) => any;
                  warn: (...args: any[]) => any;
                  error: (...args: any[]) => any;
                  debug: (...args: any[]) => any;
                  verbose: (...args: any[]) => any;
                  silly: (...args: any[]) => any;
              },
          >,
      ) => void;
  }

  Predefined scenarios for common logging test cases

  • captureAll: () => {
        info: Mock<any, any, any>;
        warn: Mock<any, any, any>;
        error: Mock<any, any, any>;
        debug: Mock<any, any, any>;
        verbose: Mock<any, any, any>;
        silly: Mock<any, any, any>;
        log: Mock<any, any, any>;
    }

    Setup logger to capture all calls without throwing

  • throwOnError: () => void

    Setup logger to throw on error level

  • silent: () => {
        info: Mock<any, any, any>;
        warn: Mock<any, any, any>;
        error: Mock<any, any, any>;
        debug: Mock<any, any, any>;
        verbose: Mock<any, any, any>;
        silly: Mock<any, any, any>;
        log: Mock<any, any, any>;
    }

    Setup logger to be silent (no-op)

  • custom: (
        implementations: Partial<
            {
                info: (...args: any[]) => any;
                warn: (...args: any[]) => any;
                error: (...args: any[]) => any;
                debug: (...args: any[]) => any;
                verbose: (...args: any[]) => any;
                silly: (...args: any[]) => any;
            },
        >,
    ) => void

    Setup logger with custom implementations