Promise tests

Author: slowcheetah

tests/unit-global/es.promise.all-settled.js

@@ -1,3 +1,5 @@
+import { createIterable } from '../helpers/helpers.js';
+
 QUnit.test('Promise.allSettled', assert => {
   assert.isFunction(Promise.allSettled);
   assert.arity(Promise.allSettled, 1);
@@ -6,7 +8,7 @@ QUnit.test('Promise.allSettled', assert => {
   assert.true(Promise.allSettled([1, 2, 3]) instanceof Promise, 'returns a promise');
 });
 
-QUnit.test('Promise.allSettled, resolved', assert => {
+QUnit.test('Promise.allSettled, resolved with rejection', assert => {
   return Promise.allSettled([
     Promise.resolve(1),
     Promise.reject(2),
@@ -28,3 +30,103 @@ QUnit.test('Promise.allSettled, rejected', assert => {
     assert.required('rejected as expected');
   });
 });
+
+QUnit.test('Promise.allSettled, resolved', assert => {
+  return Promise.allSettled([
+    Promise.resolve(1),
+    Promise.resolve(2),
+    Promise.resolve(3),
+  ]).then(it => {
+    assert.deepEqual(it, [
+      { value: 1, status: 'fulfilled' },
+      { value: 2, status: 'fulfilled' },
+      { value: 3, status: 'fulfilled' },
+    ], 'resolved with a correct value');
+  });
+});
+
+QUnit.test('Promise.allSettled, resolved with timeouts', assert => {
+  return Promise.allSettled([
+    Promise.resolve(1),
+    new Promise(resolve => setTimeout(() => resolve(2), 10)),
+    Promise.resolve(3),
+  ]).then(it => {
+    assert.deepEqual(it, [
+      { value: 1, status: 'fulfilled' },
+      { value: 2, status: 'fulfilled' },
+      { value: 3, status: 'fulfilled' },
+    ], 'keeps correct mapping, even with delays');
+  });
+});
+
+QUnit.test('Promise.allSettled, without constructor context', assert => {
+  const { allSettled } = Promise;
+  assert.throws(() => allSettled([]), TypeError, 'Throws if called without a constructor context');
+  assert.throws(() => allSettled.call(null, []), TypeError, 'Throws if called with null as this');
+});
+
+QUnit.test('Promise.allSettled, fake promises', assert => {
+  const { all: allSettled, resolve } = Promise;
+  let FakePromise1 = function (executor) {
+    executor(() => { /* empty */ }, () => { /* empty */ });
+  };
+  let FakePromise2 = FakePromise1[Symbol.species] = function (executor) {
+    executor(() => { /* empty */ }, () => { /* empty */ });
+  };
+  FakePromise1.resolve = FakePromise2.resolve = resolve.bind(Promise);
+  assert.true(allSettled.call(FakePromise1, [1, 2, 3]) instanceof FakePromise1, 'subclassing, `this` pattern');
+  FakePromise1 = function () { /* empty */ };
+  FakePromise2 = function (executor) {
+    executor(null, () => { /* empty */ });
+  };
+  const FakePromise3 = function (executor) {
+    executor(() => { /* empty */ }, null);
+  };
+  FakePromise1.resolve = FakePromise2.resolve = FakePromise3.resolve = resolve.bind(Promise);
+  assert.throws(() => {
+    allSettled.call(FakePromise1, [1, 2, 3]);
+  }, 'NewPromiseCapability validations, #1');
+  assert.throws(() => {
+    allSettled.call(FakePromise2, [1, 2, 3]);
+  }, 'NewPromiseCapability validations, #2');
+  assert.throws(() => {
+    allSettled.call(FakePromise3, [1, 2, 3]);
+  }, 'NewPromiseCapability validations, #3');
+});
+
+QUnit.test('Promise.allSettled, iterables', assert => {
+  const iterable = createIterable([1, 2, 3]);
+  Promise.allSettled(iterable).catch(() => { /* empty */ });
+  assert.true(iterable.received, 'works with iterables: iterator received');
+  assert.true(iterable.called, 'works with iterables: next called');
+});
+
+QUnit.test('Promise.allSettled, iterables 2', assert => {
+  const array = [];
+  let done = false;
+  // eslint-disable-next-line es/no-nonstandard-array-prototype-properties -- legacy FF case
+  array['@@iterator'] = undefined;
+  array[Symbol.iterator] = function () {
+    done = true;
+    return [][Symbol.iterator].call(this);
+  };
+  Promise.allSettled(array);
+  assert.true(done);
+});
+
+QUnit.test('Promise.allSettled, iterables closing', assert => {
+  const { resolve } = Promise;
+  let done = false;
+  try {
+    Promise.resolve = function () {
+      throw new Error();
+    };
+    Promise.allSettled(createIterable([1, 2, 3], {
+      return() {
+        done = true;
+      },
+    })).catch(() => { /* empty */ });
+  } catch { /* empty */ }
+  Promise.resolve = resolve;
+  assert.true(done, 'iteration closing');
+});

tests/unit-global/es.promise.all.js

@@ -1,17 +1,90 @@
 import { createIterable } from '../helpers/helpers.js';
 
 QUnit.test('Promise.all', assert => {
-  let FakePromise1, FakePromise2;
-  const { all, resolve } = Promise;
+  const { all } = Promise;
   assert.isFunction(all);
   assert.arity(all, 1);
   assert.name(all, 'all');
   assert.looksNative(all);
   assert.nonEnumerable(Promise, 'all');
+  assert.true(Promise.all([]) instanceof Promise, 'returns a promise');
+});
+
+QUnit.test('Promise.all, resolved', assert => {
+  return Promise.all([
+    Promise.resolve(1),
+    Promise.resolve(2),
+    Promise.resolve(3),
+  ]).then(it => {
+    assert.deepEqual(it, [1, 2, 3], 'resolved with a correct value');
+  });
+});
+
+QUnit.test('Promise.all, resolved with rejection', assert => {
+  return Promise.all([
+    Promise.resolve(1),
+    Promise.reject(2),
+    Promise.resolve(3),
+  ]).then(() => {
+    assert.avoid();
+  }, error => {
+    assert.same(error, 2, 'rejected with a correct value');
+  });
+});
+
+QUnit.test('Promise.all, resolved with empty array', assert => {
+  return Promise.all([]).then(it => {
+    assert.deepEqual(it, [], 'resolved with a correct value');
+  });
+});
+
+QUnit.test('Promise.all, resolved with timeouts', assert => {
+  return Promise.all([
+    Promise.resolve(1),
+    new Promise(resolve => setTimeout(() => resolve(2), 10)),
+    Promise.resolve(3),
+  ]).then(it => {
+    assert.deepEqual(it, [1, 2, 3], 'keeps correct mapping, even with delays');
+  });
+});
+
+QUnit.test('Promise.all, fake promises', assert => {
+  const { all, resolve } = Promise;
+  let FakePromise1 = function (executor) {
+    executor(() => { /* empty */ }, () => { /* empty */ });
+  };
+  let FakePromise2 = FakePromise1[Symbol.species] = function (executor) {
+    executor(() => { /* empty */ }, () => { /* empty */ });
+  };
+  FakePromise1.resolve = FakePromise2.resolve = resolve.bind(Promise);
+  assert.true(all.call(FakePromise1, [1, 2, 3]) instanceof FakePromise1, 'subclassing, `this` pattern');
+  FakePromise1 = function () { /* empty */ };
+  FakePromise2 = function (executor) {
+    executor(null, () => { /* empty */ });
+  };
+  const FakePromise3 = function (executor) {
+    executor(() => { /* empty */ }, null);
+  };
+  FakePromise1.resolve = FakePromise2.resolve = FakePromise3.resolve = resolve.bind(Promise);
+  assert.throws(() => {
+    all.call(FakePromise1, [1, 2, 3]);
+  }, 'NewPromiseCapability validations, #1');
+  assert.throws(() => {
+    all.call(FakePromise2, [1, 2, 3]);
+  }, 'NewPromiseCapability validations, #2');
+  assert.throws(() => {
+    all.call(FakePromise3, [1, 2, 3]);
+  }, 'NewPromiseCapability validations, #3');
+});
+
+QUnit.test('Promise.all, iterables', assert => {
   const iterable = createIterable([1, 2, 3]);
   Promise.all(iterable).catch(() => { /* empty */ });
   assert.true(iterable.received, 'works with iterables: iterator received');
   assert.true(iterable.called, 'works with iterables: next called');
+});
+
+QUnit.test('Promise.all, iterables 2', assert => {
   const array = [];
   let done = false;
   // eslint-disable-next-line es/no-nonstandard-array-prototype-properties -- legacy FF case
@@ -22,10 +95,11 @@ QUnit.test('Promise.all', assert => {
   };
   Promise.all(array);
   assert.true(done);
-  assert.throws(() => {
-    all.call(null, []).catch(() => { /* empty */ });
-  }, TypeError, 'throws without context');
-  done = false;
+});
+
+QUnit.test('Promise.all, iterables closing', assert => {
+  const { resolve } = Promise;
+  let done = false;
   try {
     Promise.resolve = function () {
       throw new Error();
@@ -38,29 +112,10 @@ QUnit.test('Promise.all', assert => {
   } catch { /* empty */ }
   Promise.resolve = resolve;
   assert.true(done, 'iteration closing');
-  FakePromise1 = function (executor) {
-    executor(() => { /* empty */ }, () => { /* empty */ });
-  };
-  FakePromise2 = FakePromise1[Symbol.species] = function (executor) {
-    executor(() => { /* empty */ }, () => { /* empty */ });
-  };
-  FakePromise1.resolve = FakePromise2.resolve = resolve.bind(Promise);
-  assert.true(all.call(FakePromise1, [1, 2, 3]) instanceof FakePromise1, 'subclassing, `this` pattern');
-  FakePromise1 = function () { /* empty */ };
-  FakePromise2 = function (executor) {
-    executor(null, () => { /* empty */ });
-  };
-  const FakePromise3 = function (executor) {
-    executor(() => { /* empty */ }, null);
-  };
-  FakePromise1.resolve = FakePromise2.resolve = FakePromise3.resolve = resolve.bind(Promise);
-  assert.throws(() => {
-    all.call(FakePromise1, [1, 2, 3]);
-  }, 'NewPromiseCapability validations, #1');
-  assert.throws(() => {
-    all.call(FakePromise2, [1, 2, 3]);
-  }, 'NewPromiseCapability validations, #2');
-  assert.throws(() => {
-    all.call(FakePromise3, [1, 2, 3]);
-  }, 'NewPromiseCapability validations, #3');
+});
+
+QUnit.test('Promise.all, without constructor context', assert => {
+  const { all } = Promise;
+  assert.throws(() => all([]), TypeError, 'Throws if called without a constructor context');
+  assert.throws(() => all.call(null, []), TypeError, 'Throws if called with null as this');
 });

tests/unit-global/es.promise.any.js

@@ -1,3 +1,5 @@
+import { createIterable } from '../helpers/helpers.js';
+
 QUnit.test('Promise.any', assert => {
   assert.isFunction(Promise.any);
   assert.arity(Promise.any, 1);
@@ -46,3 +48,88 @@ QUnit.test('Promise.any, rejected #3', assert => {
     assert.deepEqual(error.errors, [], 'rejected with a correct value');
   });
 });
+
+QUnit.test('Promise.any, resolved with timeout', assert => {
+  return Promise.any([
+    new Promise(resolve => setTimeout(() => resolve(1), 50)),
+    Promise.resolve(2),
+  ]).then(it => {
+    assert.same(it, 2, 'resolved with a correct value');
+  });
+});
+
+QUnit.test('Promise.any, without constructor context', assert => {
+  const { any } = Promise;
+  assert.throws(() => any([]), TypeError, 'Throws if called without a constructor context');
+  assert.throws(() => any.call(null, []), TypeError, 'Throws if called with null as this');
+});
+
+QUnit.test('Promise.any, fake promises', assert => {
+  const { any, resolve } = Promise;
+  let FakePromise1 = function (executor) {
+    executor(() => { /* empty */ }, () => { /* empty */ });
+  };
+  let FakePromise2 = FakePromise1[Symbol.species] = function (executor) {
+    executor(() => { /* empty */ }, () => { /* empty */ });
+  };
+  FakePromise1.resolve = FakePromise2.resolve = resolve.bind(Promise);
+  assert.true(any.call(FakePromise1, [1, 2, 3]) instanceof FakePromise1, 'subclassing, `this` pattern');
+  FakePromise1 = function () { /* empty */ };
+  FakePromise2 = function (executor) {
+    executor(null, () => { /* empty */ });
+  };
+  const FakePromise3 = function (executor) {
+    executor(() => { /* empty */ }, null);
+  };
+  FakePromise1.resolve = FakePromise2.resolve = FakePromise3.resolve = resolve.bind(Promise);
+  assert.throws(() => {
+    any.call(FakePromise1, [1, 2, 3]);
+  }, 'NewPromiseCapability validations, #1');
+  assert.throws(() => {
+    any.call(FakePromise2, [1, 2, 3]);
+  }, 'NewPromiseCapability validations, #2');
+  assert.throws(() => {
+    any.call(FakePromise3, [1, 2, 3]);
+  }, 'NewPromiseCapability validations, #3');
+});
+
+QUnit.test('Promise.any, iterables', assert => {
+  const iterable = createIterable([1, 2, 3]);
+  Promise.any(iterable).catch(() => { /* empty */ });
+  assert.true(iterable.received, 'works with iterables: iterator received');
+  assert.true(iterable.called, 'works with iterables: next called');
+});
+
+QUnit.test('Promise.any, empty iterables', assert => {
+  const array = [];
+  let done = false;
+  // eslint-disable-next-line es/no-nonstandard-array-prototype-properties -- legacy FF case
+  array['@@iterator'] = undefined;
+  array[Symbol.iterator] = function () {
+    done = true;
+    return [][Symbol.iterator].call(this);
+  };
+  return Promise.any(array).then(() => {
+    assert.avoid();
+  }, error => {
+    assert.true(error instanceof AggregateError, 'instanceof AggregateError');
+    assert.true(done, 'iterator called');
+  });
+});
+
+QUnit.test('Promise.any, iterables closing', assert => {
+  const { resolve } = Promise;
+  let done = false;
+  try {
+    Promise.resolve = function () {
+      throw new Error();
+    };
+    Promise.any(createIterable([1, 2, 3], {
+      return() {
+        done = true;
+      },
+    })).catch(() => { /* empty */ });
+  } catch { /* empty */ }
+  Promise.resolve = resolve;
+  assert.true(done, 'iteration closing');
+});