node/test/parallel/test-abortsignal-any.mjs

import * as common from '../common/index.mjs';
import { describe, it } from 'node:test';
import { once } from 'node:events';
import assert from 'node:assert';

describe('AbortSignal.any()', { concurrency: !process.env.TEST_PARALLEL }, () => {
  it('should throw when not receiving an array', () => {
    const expectedError = { code: 'ERR_INVALID_ARG_TYPE' };
    assert.throws(() => AbortSignal.any(), expectedError);
    assert.throws(() => AbortSignal.any(null), expectedError);
    assert.throws(() => AbortSignal.any(undefined), expectedError);
  });

  it('should throw when input contains non-signal values', () => {
    assert.throws(
      () => AbortSignal.any([AbortSignal.abort(), undefined]),
      {
        code: 'ERR_INVALID_ARG_TYPE',
        message: 'The "signals[1]" argument must be an instance of AbortSignal. Received undefined'
      },
    );
  });

  it('creates a non-aborted signal for an empty input', () => {
    const signal = AbortSignal.any([]);
    assert.strictEqual(signal.aborted, false);
    signal.addEventListener('abort', common.mustNotCall());
  });

  it('returns a new signal', () => {
    const originalSignal = new AbortController().signal;
    const signalAny = AbortSignal.any([originalSignal]);
    assert.notStrictEqual(originalSignal, signalAny);
  });

  it('returns an aborted signal if input has an aborted signal', () => {
    const signal = AbortSignal.any([AbortSignal.abort('some reason')]);
    assert.strictEqual(signal.aborted, true);
    assert.strictEqual(signal.reason, 'some reason');
    signal.addEventListener('abort', common.mustNotCall());
  });

  it('returns an aborted signal with the reason of first aborted signal input', () => {
    const signal = AbortSignal.any([AbortSignal.abort('some reason'), AbortSignal.abort('another reason')]);
    assert.strictEqual(signal.aborted, true);
    assert.strictEqual(signal.reason, 'some reason');
    signal.addEventListener('abort', common.mustNotCall());
  });

  it('returns the correct signal in the event target', async () => {
    const signal = AbortSignal.any([AbortSignal.timeout(5)]);
    const interval = setInterval(() => {}, 100000); // Keep event loop alive
    const [{ target }] = await once(signal, 'abort');
    clearInterval(interval);
    assert.strictEqual(target, signal);
    assert.ok(signal.aborted);
    assert.strictEqual(signal.reason.name, 'TimeoutError');
  });

  it('aborts with reason of first aborted signal', () => {
    const controllers = Array.from({ length: 3 }, () => new AbortController());
    const combinedSignal = AbortSignal.any(controllers.map((c) => c.signal));
    controllers[1].abort(1);
    controllers[2].abort(2);
    assert.ok(combinedSignal.aborted);
    assert.strictEqual(combinedSignal.reason, 1);
  });

  it('can accept the same signal more than once', () => {
    const controller = new AbortController();
    const signal = AbortSignal.any([controller.signal, controller.signal]);
    assert.strictEqual(signal.aborted, false);
    controller.abort('reason');
    assert.ok(signal.aborted);
    assert.strictEqual(signal.reason, 'reason');
  });

  it('handles deeply aborted signals', async () => {
    const controllers = Array.from({ length: 2 }, () => new AbortController());
    const composedSignal1 = AbortSignal.any([controllers[0].signal]);
    const composedSignal2 = AbortSignal.any([composedSignal1, controllers[1].signal]);

    composedSignal2.onabort = common.mustCall();
    controllers[0].abort();
    assert.ok(composedSignal2.aborted);
    assert.ok(composedSignal2.reason instanceof DOMException);
    assert.strictEqual(composedSignal2.reason.name, 'AbortError');
  });

  it('executes abort handlers in correct order', () => {
    const controller = new AbortController();
    const signals = [];
    signals.push(controller.signal);
    signals.push(AbortSignal.any([controller.signal]));
    signals.push(AbortSignal.any([controller.signal]));
    signals.push(AbortSignal.any([signals[0]]));
    signals.push(AbortSignal.any([signals[1]]));

    let result = '';
    signals.forEach((signal, i) => signal.addEventListener('abort', () => result += i));
    controller.abort();
    assert.strictEqual(result, '01234');
  });

  it('must accept WebIDL sequence', () => {
    const controller = new AbortController();
    const iterable = {
      *[Symbol.iterator]() {
        yield controller.signal;
        yield new AbortController().signal;
        yield new AbortController().signal;
        yield new AbortController().signal;
      },
    };
    const signal = AbortSignal.any(iterable);
    let result = 0;
    signal.addEventListener('abort', () => result += 1);
    controller.abort();
    assert.strictEqual(result, 1);
  });

  it('throws TypeError if any value does not implement AbortSignal', () => {
    const expectedError = { code: 'ERR_INVALID_ARG_TYPE' };
    assert.throws(() => AbortSignal.any([ null ]), expectedError);
    assert.throws(() => AbortSignal.any([ undefined ]), expectedError);
    assert.throws(() => AbortSignal.any([ '123' ]), expectedError);
    assert.throws(() => AbortSignal.any([ 123 ]), expectedError);
    assert.throws(() => AbortSignal.any([{}]), expectedError);
    assert.throws(() => AbortSignal.any([{ aborted: true }]), expectedError);
    assert.throws(() => AbortSignal.any([{
      aborted: true, reason: '', throwIfAborted: null,
    }]), expectedError);
  });
});