Debian Codegraph @

test/promise/all.js

raw
1 var failIfThrows = function (done) {
2 'use strict';
3
4 return function (e) {
5 done(e || new Error());
6 };
7 };
8
9 describe('Promise.all', function () {
10 'use strict';
11
12 it('should not be enumerable', function () {
13 expect(Promise).ownPropertyDescriptor('all').to.have.property('enumerable', false);
14 });
15
16 it('fulfills if passed an empty array', function (done) {
17 var iterable = [];
18
19 Promise.all(iterable).then(function (value) {
20 assert(Array.isArray(value));
21 assert.deepEqual(value, []);
22 }).then(done, failIfThrows(done));
23 });
24
25 it('fulfills if passed an empty array-like', function (done) {
26 var f = function () {
27 Promise.all(arguments).then(function (value) {
28 assert(Array.isArray(value));
29 assert.deepEqual(value, []);
30 }).then(done, failIfThrows(done));
31 };
32 f();
33 });
34
35 it('fulfills if passed an array of mixed fulfilled promises and values', function (done) {
36 var iterable = [0, Promise.resolve(1), 2, Promise.resolve(3)];
37
38 Promise.all(iterable).then(function (value) {
39 assert(Array.isArray(value));
40 assert.deepEqual(value, [0, 1, 2, 3]);
41 }).then(done, failIfThrows(done));
42 });
43
44 it('rejects if any passed promise is rejected', function (done) {
45 var foreverPending = new Promise(function () { });
46 var error = new Error('Rejected');
47 var rejected = Promise.reject(error);
48
49 var iterable = [foreverPending, rejected];
50
51 Promise.all(iterable).then(
52 function () {
53 assert(false, 'should never get here');
54 },
55 function (reason) {
56 assert.strictEqual(reason, error);
57 }
58 ).then(done, failIfThrows(done));
59 });
60
61 it('resolves foreign thenables', function (done) {
62 var normal = Promise.resolve(1);
63 var foreign = { then: function (f) { f(2); } };
64
65 var iterable = [normal, foreign];
66
67 Promise.all(iterable).then(function (value) {
68 assert.deepEqual(value, [1, 2]);
69 }).then(done, failIfThrows(done));
70 });
71
72 it('fulfills when passed an sparse array, giving `undefined` for the omitted values', function (done) {
73 /* eslint-disable no-sparse-arrays */
74 var iterable = [Promise.resolve(0), , , Promise.resolve(1)];
75 /* eslint-enable no-sparse-arrays */
76
77 Promise.all(iterable).then(function (value) {
78 assert.deepEqual(value, [0, undefined, undefined, 1]);
79 }).then(done, failIfThrows(done));
80 });
81
82 it('does not modify the input array', function (done) {
83 var input = [0, 1];
84 var iterable = input;
85
86 Promise.all(iterable).then(function (value) {
87 assert.notStrictEqual(input, value);
88 }).then(done, failIfThrows(done));
89 });
90
91 it('should reject with a TypeError if given a non-iterable', function (done) {
92 var notIterable = {};
93
94 Promise.all(notIterable).then(
95 function () {
96 assert(false, 'should never get here');
97 },
98 function (reason) {
99 assert(reason instanceof TypeError);
100 }
101 ).then(done, failIfThrows(done));
102 });
103
104 // test cases from
105 // https://github.com/domenic/promises-unwrapping/issues/89#issuecomment-33110203
106 var tamper = function (p) {
107 // eslint-disable-next-line no-param-reassign
108 p.then = function (fulfill, reject) {
109 fulfill('tampered');
110 return Promise.prototype.then.call(this, fulfill, reject);
111 };
112 return p;
113 };
114
115 it('should be robust against tampering (1)', function (done) {
116 var g = [tamper(Promise.resolve(0))];
117 // Prevent countdownHolder.[[Countdown]] from ever reaching zero
118 Promise.all(g).then(
119 function () { done(); },
120 failIfThrows(done)
121 );
122 });
123
124 it('should be robust against tampering (2)', function (done) {
125 // Promise from Promise.all resolved before arguments
126 var fulfillCalled = false;
127
128 var g = [
129 Promise.resolve(0),
130 tamper(Promise.resolve(1)),
131 Promise.resolve(2).then(function () {
132 assert(!fulfillCalled, 'should be resolved before all()');
133 }).then(function () {
134 assert(!fulfillCalled, 'should be resolved before all()');
135 })['catch'](failIfThrows(done))
136 ];
137 Promise.all(g).then(function () {
138 assert(!fulfillCalled, 'should be resolved last');
139 fulfillCalled = true;
140 }).then(done, failIfThrows(done));
141 });
142
143 it('should be robust against tampering (3)', function (done) {
144 var g = [
145 Promise.resolve(0),
146 tamper(Promise.resolve(1)),
147 Promise.reject(2)
148 ];
149 // Promise from Promise.all resolved despite rejected promise in arguments
150 Promise.all(g).then(function () {
151 throw new Error('should not reach here!');
152 }, function (e) {
153 assert.strictEqual(e, 2);
154 }).then(done, failIfThrows(done));
155 });
156
157 it('should be robust against tampering (4)', function (done) {
158 var hijack = true;
159 var actualArguments = [];
160 var P = function (resolver) {
161 var self;
162 if (hijack) {
163 hijack = false;
164 self = new Promise(function (resolve, reject) {
165 resolver(function (values) {
166 // record arguments & # of times resolve function is called
167 actualArguments.push(values.slice());
168 return resolve(values);
169 }, reject);
170 });
171 } else {
172 self = new Promise(resolver);
173 }
174 Object.setPrototypeOf(self, P.prototype);
175 return self;
176 };
177 if (!Object.setPrototypeOf) { return done(); } // skip test if on IE < 11
178 Object.setPrototypeOf(P, Promise);
179 P.prototype = Object.create(Promise.prototype, {
180 constructor: { value: P }
181 });
182 P.resolve = function (p) { return p; };
183
184 var g = [
185 Promise.resolve(0),
186 tamper(Promise.resolve(1)),
187 Promise.resolve(2)
188 ];
189
190 // Promise.all calls resolver twice
191 P.all(g)['catch'](failIfThrows(done));
192 Promise.resolve().then(function () {
193 assert.deepEqual(actualArguments, [[0, 'tampered', 2]]);
194 }).then(done, failIfThrows(done));
195 });
196 });