Merge branch 'main' into SS/fixTwitterIcon

Author: sarthak-kumar-shailendra

CHANGELOG.md

@@ -3,15 +3,18 @@
 ### Features
 
 - `[jest-config]` Add `defineConfig` and `mergeConfig` helpers for type-safe Jest config ([#15844](https://github.com/jestjs/jest/pull/15844))
+- `[jest-fake-timers]` Add `setTimerTickMode` to configure how timers advance
 
 ### Fixes
 
+- `[jest-reporters]` Fix issue where console output not displayed for GHA reporter even with `silent: false` option ([#15864](https://github.com/jestjs/jest/pull/15864))
 - `[jest-runtime]` Fix issue where user cannot utilize dynamic import despite specifying `--experimental-vm-modules` Node option ([#15842](https://github.com/jestjs/jest/pull/15842))
 - `[jest-test-sequencer]` Fix issue where failed tests due to compilation errors not getting re-executed even with `--onlyFailures` CLI option ([#15851](https://github.com/jestjs/jest/pull/15851))
 
 ### Chore & Maintenance
 
 - `[docs]` Update V30 migration guide to notify users on `jest.mock()` work with case-sensitive path ([#15849](https://github.com/jestjs/jest/pull/15849))
+- `[deps]` Update to sinon/fake-timers v15
 - Updated Twitter icon to match the latest brand guidelines.([#15868](https://github.com/jestjs/jest/pull/15869))
 
 ## 30.2.0

docs/JestObjectAPI.md

@@ -1126,6 +1126,29 @@ This function is not available when using legacy fake timers implementation.
 
 :::
 
+### `jest.setTimerTickMode(mode)`
+
+Allows configuring how fake timers advance time.
+
+Configuration options:
+
+```ts
+type TimerTickMode =
+  | {mode: 'manual'}
+  | {mode: 'nextAsync'}
+  | {mode: 'interval'; delta?: number};
+```
+
+- `manual`: Timers do not advance without explicit, manual calls to the tick APIs (`jest.advanceTimersByTime(ms)`, `jest.runAllTimers()`, etc).
+- `nextAsync`: The clock will continuously break the event loop, then run the next timer until the mode changes.
+- `interval`: This is the same as specifying `advanceTimers: true` with an `advanceTimeDelta`. If the delta is not specified, 20 will be used by default.
+
+:::info
+
+This function is not available when using legacy fake timers implementation.
+
+:::
+
 ### `jest.getRealSystemTime()`
 
 When mocking time, `Date.now()` will also be mocked. If you for some reason need access to the real current time, you can invoke this function.

e2e/fake-timers/set-timer-tick-mode/__tests__/setTimerTickMode.test.js

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+const realSetTimeout = setTimeout;
+
+describe('jest.setTimerTickMode', () => {
+  it('should not advance the clock with manual', async () => {
+    jest.useFakeTimers();
+    jest.setTimerTickMode({mode: 'manual'});
+    const spy = jest.fn();
+    setTimeout(spy, 5);
+    await new Promise(resolve => realSetTimeout(resolve, 20));
+    expect(spy).not.toHaveBeenCalled();
+  });
+
+  it('should advance the clock to next timer with nextAsync', async () => {
+    jest.useFakeTimers();
+    jest.setTimerTickMode({mode: 'nextAsync'});
+    await new Promise(resolve => setTimeout(resolve, 5000));
+    await new Promise(resolve => setTimeout(resolve, 5000));
+    await new Promise(resolve => setTimeout(resolve, 5000));
+    await new Promise(resolve => setTimeout(resolve, 5000));
+    // test should not time out
+  });
+
+  it('should advance the clock in real time with delta', async () => {
+    jest.useFakeTimers();
+    jest.setTimerTickMode({delta: 10, mode: 'interval'});
+    const spy = jest.fn();
+    setTimeout(spy, 10);
+    await new Promise(resolve => realSetTimeout(resolve, 5));
+    expect(spy).not.toHaveBeenCalled();
+    await new Promise(resolve => realSetTimeout(resolve, 5));
+    expect(spy).toHaveBeenCalled();
+  });
+});

e2e/fake-timers/set-timer-tick-mode/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "set-timer-tick-mode-e2e",
+  "private": true,
+  "version": "1.0.0"
+}

packages/jest-environment/src/index.ts

@@ -425,4 +425,25 @@ export interface Jest {
    * performance, time and timer APIs.
    */
   useRealTimers(): Jest;
+  /**
+   * Updates the mode of advancing timers when using fake timers.
+   *
+   * @param config The configuration to use for advancing timers
+   *
+   * When the mode is 'interval', timers will be advanced automatically by the [delta]
+   * milliseconds every [delta] milliseconds of real time. The default delta is 20 milliseconds.
+   *
+   * When mode is 'nextAsync', configures whether timers advance automatically to the next timer in the queue after each macrotask.
+   * This mode differs from 'interval' in that it advances all the way to the next timer, regardless
+   * of how far in the future that timer is scheduled (e.g. advanceTimersToNextTimerAsync).
+   *
+   * When mode is 'manual' (the default), timers will not advance automatically. Instead,
+   * timers must be advanced using APIs such as `advanceTimersToNextTimer`, `advanceTimersByTime`, etc.
+   *
+   * @remarks
+   * Not available when using legacy fake timers implementation.
+   */
+  setTimerTickMode(
+    config: {mode: 'manual' | 'nextAsync'} | {mode: 'interval'; delta?: number},
+  ): Jest;
 }

packages/jest-fake-timers/package.json

@@ -20,15 +20,15 @@
   },
   "dependencies": {
     "@jest/types": "workspace:*",
-    "@sinonjs/fake-timers": "^13.0.0",
+    "@sinonjs/fake-timers": "^15.0.0",
     "@types/node": "*",
     "jest-message-util": "workspace:*",
     "jest-mock": "workspace:*",
     "jest-util": "workspace:*"
   },
   "devDependencies": {
     "@jest/test-utils": "workspace:*",
-    "@types/sinonjs__fake-timers": "^8.1.5"
+    "@types/sinonjs__fake-timers": "15.0.0"
   },
   "engines": {
     "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"

packages/jest-fake-timers/src/__tests__/modernFakeTimers.test.ts

@@ -73,9 +73,7 @@ describe('FakeTimers', () => {
         Date,
         clearInterval,
         clearTimeout,
-        process: {
-          nextTick: origNextTick,
-        },
+        process: {nextTick: origNextTick},
         setInterval,
         setTimeout,
       } as unknown as typeof globalThis;
@@ -153,9 +151,7 @@ describe('FakeTimers', () => {
         Date,
         clearInterval,
         clearTimeout,
-        process: {
-          nextTick: () => {},
-        },
+        process: {nextTick: () => {}},
         setInterval,
         setTimeout,
       } as unknown as typeof globalThis;
@@ -186,9 +182,7 @@ describe('FakeTimers', () => {
         Date,
         clearInterval,
         clearTimeout,
-        process: {
-          nextTick,
-        },
+        process: {nextTick},
         setInterval,
         setTimeout,
       } as unknown as typeof globalThis;
@@ -205,9 +199,7 @@ describe('FakeTimers', () => {
         Date,
         clearInterval,
         clearTimeout,
-        process: {
-          nextTick: () => {},
-        },
+        process: {nextTick: () => {}},
         setInterval,
         setTimeout,
       } as unknown as typeof globalThis;
@@ -231,9 +223,7 @@ describe('FakeTimers', () => {
         Date,
         clearInterval,
         clearTimeout,
-        process: {
-          nextTick: () => {},
-        },
+        process: {nextTick: () => {}},
         setInterval,
         setTimeout,
       } as unknown as typeof globalThis;
@@ -902,9 +892,7 @@ describe('FakeTimers', () => {
         Date,
         clearInterval,
         clearTimeout,
-        process: {
-          nextTick: () => {},
-        },
+        process: {nextTick: () => {}},
         setImmediate: () => {},
         setInterval,
         setTimeout,
@@ -1430,6 +1418,48 @@ describe('FakeTimers', () => {
     });
   });
 
+  describe('setTimerTickMode', () => {
+    let global: typeof globalThis;
+    let timers: FakeTimers;
+    const realSetTimeout = setTimeout;
+    beforeEach(() => {
+      global = {
+        Date,
+        Promise,
+        clearInterval,
+        clearTimeout,
+        process,
+        setInterval,
+        setTimeout,
+      } as unknown as typeof globalThis;
+      timers = new FakeTimers({config: makeProjectConfig(), global});
+      timers.useFakeTimers();
+    });
+
+    afterEach(() => {
+      timers.useRealTimers();
+    });
+
+    it('should advance the clock to next timer with nextAsync', async () => {
+      timers.setTimerTickMode({mode: 'nextAsync'});
+      await new Promise(resolve => global.setTimeout(resolve, 5000));
+      await new Promise(resolve => global.setTimeout(resolve, 5000));
+      await new Promise(resolve => global.setTimeout(resolve, 5000));
+      await new Promise(resolve => global.setTimeout(resolve, 5000));
+      // test should not time out
+    });
+
+    it('should advance the clock in real time with delta', async () => {
+      timers.setTimerTickMode({delta: 10, mode: 'interval'});
+      const spy = jest.fn();
+      global.setTimeout(spy, 10);
+      await new Promise(resolve => realSetTimeout(resolve, 5));
+      expect(spy).not.toHaveBeenCalled();
+      await new Promise(resolve => realSetTimeout(resolve, 5));
+      expect(spy).toHaveBeenCalled();
+    });
+  });
+
   describe('now', () => {
     let timers: FakeTimers;
     let fakedGlobal: typeof globalThis;

packages/jest-fake-timers/src/modernFakeTimers.ts

@@ -118,7 +118,7 @@ export default class FakeTimers {
 
   runAllTicks(): void {
     if (this._checkFakeTimers()) {
-      // @ts-expect-error - doesn't exist?
+      // @ts-expect-error needs an upstream fix: https://github.com/DefinitelyTyped/DefinitelyTyped/pull/73943
       this._clock.runMicrotasks();
     }
   }
@@ -156,6 +156,15 @@ export default class FakeTimers {
     }
   }
 
+  setTimerTickMode(tickModeConfig: {
+    mode: 'interval' | 'manual' | 'nextAsync';
+    delta?: number;
+  }): void {
+    if (this._checkFakeTimers()) {
+      this._clock.setTickMode(tickModeConfig);
+    }
+  }
+
   getRealSystemTime(): number {
     return Date.now();
   }

packages/jest-reporters/src/GitHubActionsReporter.ts

@@ -7,6 +7,7 @@
 
 import {stripVTControlCharacters as stripAnsi} from 'util';
 import chalk from 'chalk';
+import {type ConsoleBuffer, getConsoleOutput} from '@jest/console';
 import type {
   AggregatedResult,
   AssertionResult,
@@ -66,12 +67,14 @@ type ResultTree = {
 export default class GitHubActionsReporter extends BaseReporter {
   static readonly filename = __filename;
   private readonly options: {silent: boolean};
+  private readonly globalConfig: Config.GlobalConfig;
 
   constructor(
-    _globalConfig: Config.GlobalConfig,
+    globalConfig: Config.GlobalConfig,
     reporterOptions: {silent?: boolean} = {},
   ) {
     super();
+    this.globalConfig = globalConfig;
     this.options = {
       silent:
         typeof reporterOptions.silent === 'boolean'
@@ -90,7 +93,7 @@ export default class GitHubActionsReporter extends BaseReporter {
       this.printFullResult(test.context, testResult);
     }
     if (this.isLastTestSuite(aggregatedResults)) {
-      this.printFailedTestLogs(test, aggregatedResults);
+      this.printFailedTestLogs(test, testResult.console, aggregatedResults);
     }
   }
 
@@ -179,7 +182,7 @@ export default class GitHubActionsReporter extends BaseReporter {
       testDir,
       results.perfStats,
     );
-    this.printResultTree(resultTree);
+    this.printResultTree(resultTree, context.config, results.console);
   }
 
   private arrayEqual(a1: Array<any>, a2: Array<any>): boolean {
@@ -311,7 +314,11 @@ export default class GitHubActionsReporter extends BaseReporter {
     return node;
   }
 
-  private printResultTree(resultTree: ResultTree): void {
+  private printResultTree(
+    resultTree: ResultTree,
+    config: Config.ProjectConfig,
+    consoleLog: ConsoleBuffer | undefined,
+  ): void {
     let perfMs;
     if (resultTree.performanceInfo.slow) {
       perfMs = ` (${chalk.red.inverse(
@@ -324,6 +331,9 @@ export default class GitHubActionsReporter extends BaseReporter {
       this.startGroup(
         `${chalk.bold.green.inverse('PASS')} ${resultTree.name}${perfMs}`,
       );
+      if (consoleLog && !this.options.silent) {
+        this.log(getConsoleOutput(consoleLog, config, this.globalConfig));
+      }
       for (const child of resultTree.children) {
         this.recursivePrintResultTree(child, true, 1);
       }
@@ -401,6 +411,7 @@ export default class GitHubActionsReporter extends BaseReporter {
 
   private printFailedTestLogs(
     context: Test,
+    consoleLog: ConsoleBuffer | undefined,
     testResults: AggregatedResult,
   ): boolean {
     const rootDir = context.context.config.rootDir;
@@ -416,6 +427,15 @@ export default class GitHubActionsReporter extends BaseReporter {
           written = true;
         }
         this.startGroup(`Errors thrown in ${testDir}`);
+        if (consoleLog && !this.options.silent) {
+          this.log(
+            getConsoleOutput(
+              consoleLog,
+              context.context.config,
+              this.globalConfig,
+            ),
+          );
+        }
         this.log(result.failureMessage);
         this.endGroup();
       }