test-abortcontroller.js

// Flags: --expose-gc
'use strict';

const common = require('../common');
const { inspect } = require('util');

const assert = require('assert');

const {
  test,
  mock,
} = require('node:test');

const { setTimeout: sleep } = require('timers/promises');

// All of the the tests in this file depend on public-facing Node.js APIs.
// For tests that depend on Node.js internal APIs, please add them to
// test-abortcontroller-internal.js instead.

test('Abort is fired with the correct event type on AbortControllers', () => {
  // Tests that abort is fired with the correct event type on AbortControllers
  const ac = new AbortController();
  assert.ok(ac.signal);

  const fn = mock.fn(common.mustCall((event) => {
    assert.ok(event);
    assert.strictEqual(event.type, 'abort');
  }, 2));

  ac.signal.onabort = fn;
  ac.signal.addEventListener('abort', fn);

  ac.abort();
  ac.abort();
  assert.ok(ac.signal.aborted);

  assert.strictEqual(fn.mock.calls.length, 2);
});

test('Abort events are trusted', () => {
  // Tests that abort events are trusted
  const ac = new AbortController();

  const fn = mock.fn(common.mustCall((event) => {
    assert.ok(event.isTrusted);
  }));

  ac.signal.onabort = fn;
  ac.abort();
  assert.strictEqual(fn.mock.calls.length, 1);
});

test('Abort events have the same isTrusted reference', () => {
  // Tests that abort events have the same `isTrusted` reference
  const first = new AbortController();
  const second = new AbortController();
  let ev1, ev2;
  const ev3 = new Event('abort');

  first.signal.addEventListener('abort', (event) => {
    ev1 = event;
  });
  second.signal.addEventListener('abort', (event) => {
    ev2 = event;
  });
  first.abort();
  second.abort();
  const firstTrusted = Reflect.getOwnPropertyDescriptor(Object.getPrototypeOf(ev1), 'isTrusted').get;
  const secondTrusted = Reflect.getOwnPropertyDescriptor(Object.getPrototypeOf(ev2), 'isTrusted').get;
  const untrusted = Reflect.getOwnPropertyDescriptor(Object.getPrototypeOf(ev3), 'isTrusted').get;
  assert.strictEqual(firstTrusted, secondTrusted);
  assert.strictEqual(untrusted, firstTrusted);
});

test('AbortSignal is impossible to construct manually', () => {
  // Tests that AbortSignal is impossible to construct manually
  const ac = new AbortController();
  assert.throws(() => new ac.signal.constructor(), {
    code: 'ERR_ILLEGAL_CONSTRUCTOR',
  });
});

test('Symbol.toStringTag is correct', () => {
  // Symbol.toStringTag
  const toString = (o) => Object.prototype.toString.call(o);
  const ac = new AbortController();
  assert.strictEqual(toString(ac), '[object AbortController]');
  assert.strictEqual(toString(ac.signal), '[object AbortSignal]');
});

test('AbortSignal.abort() creates an already aborted signal', () => {
  const signal = AbortSignal.abort();
  assert.ok(signal.aborted);
});

test('AbortController properties and methods valiate the receiver', () => {
  const acSignalGet = Object.getOwnPropertyDescriptor(
    AbortController.prototype,
    'signal'
  ).get;
  const acAbort = AbortController.prototype.abort;

  const goodController = new AbortController();
  assert.ok(acSignalGet.call(goodController));
  acAbort.call(goodController);

  const badAbortControllers = [
    null,
    undefined,
    0,
    NaN,
    true,
    'AbortController',
    { __proto__: AbortController.prototype },
  ];
  for (const badController of badAbortControllers) {
    assert.throws(
      () => acSignalGet.call(badController),
      { name: 'TypeError' }
    );
    assert.throws(
      () => acAbort.call(badController),
      { name: 'TypeError' }
    );
  }
});

test('AbortSignal properties validate the receiver', () => {
  const signalAbortedGet = Object.getOwnPropertyDescriptor(
    AbortSignal.prototype,
    'aborted'
  ).get;

  const goodSignal = new AbortController().signal;
  assert.strictEqual(signalAbortedGet.call(goodSignal), false);

  const badAbortSignals = [
    null,
    undefined,
    0,
    NaN,
    true,
    'AbortSignal',
    { __proto__: AbortSignal.prototype },
  ];
  for (const badSignal of badAbortSignals) {
    assert.throws(
      () => signalAbortedGet.call(badSignal),
      { name: 'TypeError' }
    );
  }
});

test('AbortController inspection depth 1 or null works', () => {
  const ac = new AbortController();
  assert.strictEqual(inspect(ac, { depth: 1 }),
                     'AbortController { signal: [AbortSignal] }');
  assert.strictEqual(inspect(ac, { depth: null }),
                     'AbortController { signal: AbortSignal { aborted: false } }');
});

test('AbortSignal reason is set correctly', () => {
  // Test AbortSignal.reason
  const ac = new AbortController();
  ac.abort('reason');
  assert.strictEqual(ac.signal.reason, 'reason');
});

test('AbortSignal reasonable is set correctly with AbortSignal.abort()', () => {
  // Test AbortSignal.reason
  const signal = AbortSignal.abort('reason');
  assert.strictEqual(signal.reason, 'reason');
});

test('AbortSignal.timeout() works as expected', async () => {
  // Test AbortSignal timeout
  const signal = AbortSignal.timeout(10);
  assert.ok(!signal.aborted);

  const { promise, resolve } = Promise.withResolvers();

  const fn = mock.fn(common.mustCall(() => {
    assert.ok(signal.aborted);
    assert.strictEqual(signal.reason.name, 'TimeoutError');
    assert.strictEqual(signal.reason.code, 23);
    resolve();
  }));

  setTimeout(fn, 20);
  await promise;
});

test('AbortSignal.timeout() does not prevent the signal from being collected', async () => {
  // Test AbortSignal timeout doesn't prevent the signal
  // from being garbage collected.
  let ref;
  {
    ref = new globalThis.WeakRef(AbortSignal.timeout(1_200_000));
  }

  await sleep(10);
  globalThis.gc();
  assert.strictEqual(ref.deref(), undefined);
});

test('AbortSignal with a timeout is not collected while there is an active listener', async () => {
  // Test that an AbortSignal with a timeout is not gc'd while
  // there is an active listener on it.
  let ref;
  function handler() {}
  {
    ref = new globalThis.WeakRef(AbortSignal.timeout(1_200_000));
    ref.deref().addEventListener('abort', handler);
  }

  await sleep(10);
  globalThis.gc();
  assert.notStrictEqual(ref.deref(), undefined);
  assert.ok(ref.deref() instanceof AbortSignal);

  ref.deref().removeEventListener('abort', handler);

  await sleep(10);
  globalThis.gc();
  assert.strictEqual(ref.deref(), undefined);
});

test('AbortSignal.timeout() correctly validates delay argument', () => {
  for (const value of [0, -0, -0.9, Number.MAX_SAFE_INTEGER]) {
    AbortSignal.timeout(value);
  }

  for (const value of [-1, Number.MAX_SAFE_INTEGER + 1, Number.NaN]) {
    assert.throws(() => AbortSignal.timeout(value), { code: 'ERR_INVALID_ARG_VALUE' });
  }
});

test('Setting a long timeout should not keep the process open', () => {
  AbortSignal.timeout(1_200_000);
});

test('AbortSignal.reason should default', () => {
  // Test AbortSignal.reason default
  const signal = AbortSignal.abort();
  assert.ok(signal.reason instanceof DOMException);
  assert.strictEqual(signal.reason.code, 20);

  const ac = new AbortController();
  ac.abort();
  assert.ok(ac.signal.reason instanceof DOMException);
  assert.strictEqual(ac.signal.reason.code, 20);
});

test('abortSignal.throwIfAborted() works as expected', () => {
  // Test abortSignal.throwIfAborted()
  assert.throws(() => AbortSignal.abort().throwIfAborted(), {
    code: 20,
    name: 'AbortError',
  });

  // Does not throw because it's not aborted.
  const ac = new AbortController();
  ac.signal.throwIfAborted();
});

test('abortSignal.throwIfAobrted() works as expected (2)', () => {
  const originalDesc = Reflect.getOwnPropertyDescriptor(AbortSignal.prototype, 'aborted');
  const actualReason = new Error();
  Reflect.defineProperty(AbortSignal.prototype, 'aborted', { value: false });
  assert.throws(() => AbortSignal.abort(actualReason).throwIfAborted(), actualReason);
  Reflect.defineProperty(AbortSignal.prototype, 'aborted', originalDesc);
});

test('abortSignal.throwIfAobrted() works as expected (3)', () => {
  const originalDesc = Reflect.getOwnPropertyDescriptor(AbortSignal.prototype, 'reason');
  const actualReason = new Error();
  const fakeExcuse = new Error();
  Reflect.defineProperty(AbortSignal.prototype, 'reason', { value: fakeExcuse });
  assert.throws(() => AbortSignal.abort(actualReason).throwIfAborted(), actualReason);
  Reflect.defineProperty(AbortSignal.prototype, 'reason', originalDesc);
});