test_runner: fix AbortSignal.timeout to be mock-timers compatible; add regression test

Author: DeveloperViraj

lib/internal/test_runner/mock/mock_timers.js

@@ -34,6 +34,7 @@ const {
 } = require('internal/errors');
 
 const { addAbortListener } = require('internal/events/abort_listener');
+const { AbortController, AbortSignal } = require('internal/abort_controller');
 
 const { TIMEOUT_MAX } = require('internal/timers');
 
@@ -59,10 +60,14 @@ function abortIt(signal) {
   return new AbortError(undefined, { __proto__: null, cause: signal.reason });
 }
 
-/**
- * @enum {('setTimeout'|'setInterval'|'setImmediate'|'Date'|'scheduler.wait')[]} Supported timers
- */
-const SUPPORTED_APIS = ['setTimeout', 'setInterval', 'setImmediate', 'Date', 'scheduler.wait'];
+const SUPPORTED_APIS = [
+  'setTimeout',
+  'setInterval',
+  'setImmediate',
+  'Date',
+  'scheduler.wait',
+  'AbortSignal.timeout',
+];
 const TIMERS_DEFAULT_INTERVAL = {
   __proto__: null,
   setImmediate: -1,
@@ -115,6 +120,7 @@ class MockTimers {
   #realPromisifiedSetImmediate;
 
   #nativeDateDescriptor;
+  #realAbortSignalTimeout;
 
   #timersInContext = [];
   #isEnabled = false;
@@ -297,6 +303,18 @@ class MockTimers {
     );
   }
 
+  #storeOriginalAbortSignalTimeout() {
+    this.#realAbortSignalTimeout = ObjectGetOwnPropertyDescriptor(AbortSignal, 'timeout');
+  }
+
+  #restoreOriginalAbortSignalTimeout() {
+    if (this.#realAbortSignalTimeout) {
+      ObjectDefineProperty(AbortSignal, 'timeout', this.#realAbortSignalTimeout);
+    } else {
+      delete AbortSignal.timeout;
+    }
+  }
+
   #createTimer(isInterval, callback, delay, ...args) {
     if (delay > TIMEOUT_MAX) {
       delay = 1;
@@ -604,6 +622,28 @@ class MockTimers {
           this.#nativeDateDescriptor = ObjectGetOwnPropertyDescriptor(globalThis, 'Date');
           globalThis.Date = this.#createDate();
         },
+        'AbortSignal.timeout': () => {
+          this.#storeOriginalAbortSignalTimeout();
+          const mock = this;
+          ObjectDefineProperty(AbortSignal, 'timeout', {
+            __proto__: null,
+            configurable: true,
+            writable: true,
+            value: function mockableAbortSignalTimeout(delay) {
+              if (NumberIsNaN(delay)) {
+                throw new ERR_INVALID_ARG_VALUE('delay', delay, 'delay must be a number');
+              }
+              const controller = new AbortController();
+              const timer = mock.#setTimeout(
+                () => {
+                  controller.abort();
+                },
+                delay
+              );
+              return controller.signal;
+            },
+          });
+        },
       },
       toReal: {
         '__proto__': null,
@@ -622,6 +662,9 @@ class MockTimers {
         'Date': () => {
           ObjectDefineProperty(globalThis, 'Date', this.#nativeDateDescriptor);
         },
+        'AbortSignal.timeout': () => {
+          this.#restoreOriginalAbortSignalTimeout();
+        },
       },
     };
 
@@ -664,10 +707,13 @@ class MockTimers {
   }
 
   /**
-   * @typedef {{apis: SUPPORTED_APIS;now: number | Date;}} EnableOptions Options to enable the timers
-   * @property {SUPPORTED_APIS} apis List of timers to enable, defaults to all
-   * @property {number | Date} now The epoch to which the timers should be set to, defaults to 0
+   * EnableOptions type:
+   *
+   * @typedef {Object} EnableOptions
+   * @property {Array<string>} apis List of timers to enable, defaults to all
+   * @property {number|Date} now The epoch to which the timers should be set, defaults to 0
    */
+
   /**
    * Enables the MockTimers replacing the native timers with the fake ones.
    * @param {EnableOptions} [options]
@@ -686,8 +732,8 @@ class MockTimers {
 
     internalOptions.apis ||= SUPPORTED_APIS;
 
-    validateStringArray(internalOptions.apis, 'options.apis');
     // Check that the timers passed are supported
+    validateStringArray(internalOptions.apis, 'options.apis');
     ArrayPrototypeForEach(internalOptions.apis, (timer) => {
       if (!ArrayPrototypeIncludes(SUPPORTED_APIS, timer)) {
         throw new ERR_INVALID_ARG_VALUE(

test/parallel/test-mock-timers-abortsignal-timeout.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const assert = require('assert');
+const { MockTimers } = require('internal/test_runner/mock/mock_timers');
+const { AbortSignal } = require('internal/abort_controller');
+
+{
+  const mock = new MockTimers();
+  mock.enable({ apis: ['AbortSignal.timeout'] });
+
+  try {
+    const signal = AbortSignal.timeout(50);
+
+    assert.strictEqual(
+      signal.aborted,
+      false,
+      'signal should not be aborted initially'
+    );
+
+    mock.tick(49);
+    assert.strictEqual(
+      signal.aborted,
+      false,
+      'signal should not be aborted after 49ms'
+    );
+
+    mock.tick(1);
+    assert.strictEqual(
+      signal.aborted,
+      true,
+      'signal should be aborted after total 50ms'
+    );
+  } finally {
+    mock.reset();
+  }
+}