Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(33)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: third_party/WebKit/LayoutTests/http/tests/streams/writable-streams/aborting.js

Issue 2772293002: Update WritableStream to new standard version (Closed)
Patch Set: Changes from domenic@ review Created 3 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « third_party/WebKit/LayoutTests/external/wpt/streams/writable-streams/write.sharedworker-expected.txt ('k') | third_party/WebKit/LayoutTests/http/tests/streams/writable-streams/aborting.https.html » ('j') | third_party/WebKit/Source/core/streams/WritableStream.js » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 'use strict';
2
3 if (self.importScripts) {
4 self.importScripts('/resources/testharness.js');
5 self.importScripts('../resources/test-utils.js');
6 self.importScripts('../resources/recording-streams.js');
7 }
8
9 const error1 = new Error('error1');
10 error1.name = 'error1';
11
12 const error2 = new Error('error2');
13 error2.name = 'error2';
14
15 promise_test(t => {
16 const ws = new WritableStream({
17 write() {
18 return new Promise(() => { }); // forever-pending, so normally .ready woul d not fulfill.
19 }
20 });
21
22 const writer = ws.getWriter();
23 const writePromise = writer.write('a');
24
25 const readyPromise = writer.ready;
26
27 writer.abort(error1);
28
29 assert_equals(writer.ready, readyPromise, 'the ready promise property should n ot change');
30
31 return Promise.all([
32 promise_rejects(t, new TypeError(), readyPromise, 'the ready promise should reject with a TypeError'),
33 promise_rejects(t, new TypeError(), writePromise, 'the write() promise shoul d reject with a TypeError')
34 ]);
35 }, 'Aborting a WritableStream should cause the writer\'s unsettled ready promise to reject');
36
37 promise_test(t => {
38 const ws = new WritableStream();
39
40 const writer = ws.getWriter();
41 writer.write('a');
42
43 const readyPromise = writer.ready;
44
45 return readyPromise.then(() => {
46 writer.abort(error1);
47
48 assert_not_equals(writer.ready, readyPromise, 'the ready promise property sh ould change');
49 return promise_rejects(t, new TypeError(), writer.ready, 'the ready promise should reject with a TypeError');
50 });
51 }, 'Aborting a WritableStream should cause the writer\'s fulfilled ready promise to reset to a rejected one');
52
53 promise_test(t => {
54 const ws = new WritableStream();
55 const writer = ws.getWriter();
56
57 writer.releaseLock();
58
59 return promise_rejects(t, new TypeError(), writer.abort(), 'abort() should rej ect with a TypeError');
60 }, 'abort() on a released writer rejects');
61
62 promise_test(t => {
63 const ws = recordingWritableStream();
64
65 return delay(0)
66 .then(() => {
67 const writer = ws.getWriter();
68
69 writer.abort();
70
71 return Promise.all([
72 promise_rejects(t, new TypeError(), writer.write(1), 'write(1) must reje ct with a TypeError'),
73 promise_rejects(t, new TypeError(), writer.write(2), 'write(2) must reje ct with a TypeError')
74 ]);
75 })
76 .then(() => {
77 assert_array_equals(ws.events, ['abort', undefined]);
78 });
79 }, 'Aborting a WritableStream immediately prevents future writes');
80
81 promise_test(t => {
82 const ws = recordingWritableStream();
83 const results = [];
84
85 return delay(0)
86 .then(() => {
87 const writer = ws.getWriter();
88
89 results.push(
90 writer.write(1),
91 promise_rejects(t, new TypeError(), writer.write(2), 'write(2) must reje ct with a TypeError'),
92 promise_rejects(t, new TypeError(), writer.write(3), 'write(3) must reje ct with a TypeError')
93 );
94
95 const abortPromise = writer.abort();
96
97 results.push(
98 promise_rejects(t, new TypeError(), writer.write(4), 'write(4) must reje ct with a TypeError'),
99 promise_rejects(t, new TypeError(), writer.write(5), 'write(5) must reje ct with a TypeError')
100 );
101
102 return abortPromise;
103 }).then(() => {
104 assert_array_equals(ws.events, ['write', 1, 'abort', undefined]);
105
106 return Promise.all(results);
107 });
108 }, 'Aborting a WritableStream prevents further writes after any that are in prog ress');
109
110 promise_test(() => {
111 const ws = new WritableStream({
112 abort() {
113 return 'Hello';
114 }
115 });
116 const writer = ws.getWriter();
117
118 return writer.abort('a').then(value => {
119 assert_equals(value, undefined, 'fulfillment value must be undefined');
120 });
121 }, 'Fulfillment value of ws.abort() call must be undefined even if the underlyin g sink returns a non-undefined value');
122
123 promise_test(t => {
124 const ws = new WritableStream({
125 abort() {
126 throw error1;
127 }
128 });
129 const writer = ws.getWriter();
130
131 return promise_rejects(t, error1, writer.abort(undefined),
132 'rejection reason of abortPromise must be the error thrown by abort');
133 }, 'WritableStream if sink\'s abort throws, the promise returned by writer.abort () rejects');
134
135 promise_test(t => {
136 const ws = new WritableStream({
137 abort() {
138 throw error1;
139 }
140 });
141
142 return promise_rejects(t, error1, ws.abort(undefined),
143 'rejection reason of abortPromise must be the error thrown by abort');
144 }, 'WritableStream if sink\'s abort throws, the promise returned by ws.abort() r ejects');
145
146 promise_test(t => {
147 let resolveWritePromise;
148 const ws = new WritableStream({
149 write() {
150 return new Promise(resolve => {
151 resolveWritePromise = resolve;
152 });
153 },
154 abort() {
155 throw error1;
156 }
157 });
158
159 const writer = ws.getWriter();
160
161 writer.write().catch(() => {});
162 return flushAsyncEvents().then(() => {
163 const abortPromise = writer.abort(undefined);
164
165 resolveWritePromise();
166 return promise_rejects(t, error1, abortPromise,
167 'rejection reason of abortPromise must be the error thrown by abort');
168 });
169 }, 'WritableStream if sink\'s abort throws, for an abort performed during a writ e, the promise returned by ' +
170 'ws.abort() rejects');
171
172 test(() => {
173 const ws = recordingWritableStream();
174 const writer = ws.getWriter();
175
176 writer.abort(error1);
177
178 assert_array_equals(ws.events, ['abort', error1]);
179 }, 'Aborting a WritableStream passes through the given reason');
180
181 promise_test(t => {
182 const ws = new WritableStream();
183 const writer = ws.getWriter();
184
185 writer.abort(error1);
186
187 return Promise.all([
188 promise_rejects(t, new TypeError(), writer.write(), 'writing should reject w ith a TypeError'),
189 promise_rejects(t, new TypeError(), writer.close(), 'closing should reject w ith a TypeError'),
190 promise_rejects(t, new TypeError(), writer.abort(), 'aborting should reject with a TypeError'),
191 promise_rejects(t, new TypeError(), writer.closed, 'closed should reject wit h a TypeError')
192 ]);
193 }, 'Aborting a WritableStream puts it in an errored state, with a TypeError as t he stored error');
194
195 promise_test(t => {
196 const ws = new WritableStream();
197 const writer = ws.getWriter();
198
199 const writePromise = promise_rejects(t, new TypeError(), writer.write('a'),
200 'writing should reject with a TypeError');
201
202 writer.abort(error1);
203
204 return writePromise;
205 }, 'Aborting a WritableStream causes any outstanding write() promises to be reje cted with a TypeError');
206
207 promise_test(t => {
208 const ws = new WritableStream();
209 const writer = ws.getWriter();
210
211 const closePromise = writer.close();
212 writer.abort(error1);
213
214 return Promise.all([
215 promise_rejects(t, new TypeError(), writer.closed, 'closed should reject wit h a TypeError'),
216 promise_rejects(t, new TypeError(), closePromise, 'close() should reject wit h a TypeError')
217 ]);
218 }, 'Closing but then immediately aborting a WritableStream causes the stream to error');
219
220 promise_test(t => {
221 let resolveClose;
222 const ws = new WritableStream({
223 close() {
224 return new Promise(resolve => {
225 resolveClose = resolve;
226 });
227 }
228 });
229 const writer = ws.getWriter();
230
231 const closePromise = writer.close();
232
233 return delay(0).then(() => {
234 writer.abort(error1);
235 resolveClose();
236 return Promise.all([
237 promise_rejects(t, new TypeError(), writer.closed, 'closed should reject w ith a TypeError'),
238 closePromise
239 ]);
240 });
241 }, 'Closing a WritableStream and aborting it while it closes causes the stream t o error');
242
243 promise_test(() => {
244 const ws = new WritableStream();
245 const writer = ws.getWriter();
246
247 writer.close();
248
249 return delay(0).then(() => writer.abort());
250 }, 'Aborting a WritableStream after it is closed is a no-op');
251
252 promise_test(t => {
253 // Testing that per https://github.com/whatwg/streams/issues/620#issuecomment- 263483953 the fallback to close was
254 // removed.
255
256 // Cannot use recordingWritableStream since it always has an abort
257 let closeCalled = false;
258 const ws = new WritableStream({
259 close() {
260 closeCalled = true;
261 }
262 });
263
264 const writer = ws.getWriter();
265
266 writer.abort();
267
268 return promise_rejects(t, new TypeError(), writer.closed, 'closed should rejec t with a TypeError').then(() => {
269 assert_false(closeCalled, 'close must not have been called');
270 });
271 }, 'WritableStream should NOT call underlying sink\'s close if no abort is suppl ied (historical)');
272
273 promise_test(() => {
274 let thenCalled = false;
275 const ws = new WritableStream({
276 abort() {
277 return {
278 then(onFulfilled) {
279 thenCalled = true;
280 onFulfilled();
281 }
282 };
283 }
284 });
285 const writer = ws.getWriter();
286 return writer.abort().then(() => assert_true(thenCalled, 'then() should be cal led'));
287 }, 'returning a thenable from abort() should work');
288
289 promise_test(t => {
290 const ws = new WritableStream({
291 write() {
292 return flushAsyncEvents();
293 }
294 });
295 const writer = ws.getWriter();
296 return writer.ready.then(() => {
297 const writePromise = writer.write('a');
298 writer.abort(error1);
299 let closedResolved = false;
300 return Promise.all([
301 writePromise.then(() => assert_false(closedResolved, '.closed should not r esolve before write()')),
302 promise_rejects(t, new TypeError(), writer.closed, '.closed should reject' ).then(() => {
303 closedResolved = true;
304 })
305 ]);
306 });
307 }, '.closed should not resolve before fulfilled write()');
308
309 promise_test(t => {
310 const ws = new WritableStream({
311 write() {
312 return Promise.reject(error1);
313 }
314 });
315 const writer = ws.getWriter();
316 return writer.ready.then(() => {
317 const writePromise = writer.write('a');
318 const abortPromise = writer.abort(error2);
319 let closedResolved = false;
320 return Promise.all([
321 promise_rejects(t, error1, writePromise, 'write() should reject')
322 .then(() => assert_false(closedResolved, '.closed should not resolve b efore write()')),
323 promise_rejects(t, error1, writer.closed, '.closed should reject')
324 .then(() => {
325 closedResolved = true;
326 }),
327 promise_rejects(t, error1, abortPromise, 'abort() should reject')]);
328 });
329 }, '.closed should not resolve before rejected write(); write() error should ove rwrite abort() error');
330
331 promise_test(t => {
332 const ws = new WritableStream({
333 write() {
334 return flushAsyncEvents();
335 }
336 }, new CountQueuingStrategy(4));
337 const writer = ws.getWriter();
338 return writer.ready.then(() => {
339 const settlementOrder = [];
340 return Promise.all([
341 writer.write('1').then(() => settlementOrder.push(1)),
342 promise_rejects(t, new TypeError(), writer.write('2'), 'first queued write should be rejected')
343 .then(() => settlementOrder.push(2)),
344 promise_rejects(t, new TypeError(), writer.write('3'), 'second queued writ e should be rejected')
345 .then(() => settlementOrder.push(3)),
346 writer.abort(error1)
347 ]).then(() => assert_array_equals([1, 2, 3], settlementOrder, 'writes should be satisfied in order'));
348 });
349 }, 'writes should be satisfied in order when aborting');
350
351 promise_test(t => {
352 const ws = new WritableStream({
353 write() {
354 return Promise.reject(error1);
355 }
356 }, new CountQueuingStrategy(4));
357 const writer = ws.getWriter();
358 return writer.ready.then(() => {
359 const settlementOrder = [];
360 return Promise.all([
361 promise_rejects(t, error1, writer.write('1'), 'pending write should be rej ected')
362 .then(() => settlementOrder.push(1)),
363 promise_rejects(t, error1, writer.write('2'), 'first queued write should b e rejected')
364 .then(() => settlementOrder.push(2)),
365 promise_rejects(t, error1, writer.write('3'), 'second queued write should be rejected')
366 .then(() => settlementOrder.push(3)),
367 promise_rejects(t, error1, writer.abort(error1), 'abort should be rejected ')
368 ]).then(() => assert_array_equals([1, 2, 3], settlementOrder, 'writes should be satisfied in order'));
369 });
370 }, 'writes should be satisfied in order after rejected write when aborting');
371
372 promise_test(t => {
373 const ws = new WritableStream({
374 write() {
375 return Promise.reject(error1);
376 }
377 });
378 const writer = ws.getWriter();
379 return writer.ready.then(() => {
380 return Promise.all([
381 promise_rejects(t, error1, writer.write('a'), 'writer.write() should rejec t with error from underlying write()'),
382 promise_rejects(t, error1, writer.close(), 'writer.close() should reject w ith error from underlying write()'),
383 promise_rejects(t, error1, writer.abort(), 'writer.abort() should reject w ith error from underlying write()')
384 ]);
385 });
386 }, 'close() should use error from underlying write() on abort');
387
388 promise_test(() => {
389 let resolveWrite;
390 let abortCalled = false;
391 const ws = new WritableStream({
392 write() {
393 return new Promise(resolve => {
394 resolveWrite = resolve;
395 });
396 },
397 abort() {
398 abortCalled = true;
399 }
400 });
401
402 const writer = ws.getWriter();
403 return writer.ready.then(() => {
404 writer.write('a');
405 const abortPromise = writer.abort();
406 return flushAsyncEvents().then(() => {
407 assert_false(abortCalled, 'abort should not be called while write is pendi ng');
408 resolveWrite();
409 return abortPromise.then(() => assert_true(abortCalled, 'abort should be c alled'));
410 });
411 });
412 }, 'underlying abort() should not be called until underlying write() completes') ;
413
414 promise_test(() => {
415 let resolveClose;
416 let abortCalled = false;
417 const ws = new WritableStream({
418 close() {
419 return new Promise(resolve => {
420 resolveClose = resolve;
421 });
422 },
423 abort() {
424 abortCalled = true;
425 }
426 });
427
428 const writer = ws.getWriter();
429 return writer.ready.then(() => {
430 writer.close();
431 const abortPromise = writer.abort();
432 return flushAsyncEvents().then(() => {
433 assert_false(abortCalled, 'underlying abort should not be called while clo se is pending');
434 resolveClose();
435 return abortPromise.then(() => {
436 assert_false(abortCalled, 'underlying abort should not be called after c lose completes');
437 });
438 });
439 });
440 }, 'underlying abort() should not be called if underlying close() has started');
441
442 promise_test(t => {
443 let rejectClose;
444 let abortCalled = false;
445 const ws = new WritableStream({
446 close() {
447 return new Promise((resolve, reject) => {
448 rejectClose = reject;
449 });
450 },
451 abort() {
452 abortCalled = true;
453 }
454 });
455
456 const writer = ws.getWriter();
457 return writer.ready.then(() => {
458 const closePromise = writer.close();
459 const abortPromise = writer.abort();
460 return flushAsyncEvents().then(() => {
461 assert_false(abortCalled, 'underlying abort should not be called while clo se is pending');
462 rejectClose(error1);
463 return promise_rejects(t, error1, abortPromise, 'abort should reject with the same reason').then(() => {
464 return promise_rejects(t, error1, closePromise, 'close should reject wit h the same reason');
465 }).then(() => {
466 assert_false(abortCalled, 'underlying abort should not be called after c lose completes');
467 });
468 });
469 });
470 }, 'if underlying close() has started and then rejects, the abort() and close() promises should reject with the ' +
471 'underlying close rejection reason');
472
473 promise_test(t => {
474 let resolveWrite;
475 let abortCalled = false;
476 const ws = new WritableStream({
477 write() {
478 return new Promise(resolve => {
479 resolveWrite = resolve;
480 });
481 },
482 abort() {
483 abortCalled = true;
484 }
485 });
486
487 const writer = ws.getWriter();
488 return writer.ready.then(() => {
489 writer.write('a');
490 const closePromise = writer.close();
491 const abortPromise = writer.abort();
492 return flushAsyncEvents().then(() => {
493 assert_false(abortCalled, 'abort should not be called while write is pendi ng');
494 resolveWrite();
495 return abortPromise.then(() => {
496 assert_true(abortCalled, 'abort should be called after write completes') ;
497 return promise_rejects(t, new TypeError(), closePromise, 'promise return ed by close() should be rejected');
498 });
499 });
500 });
501 }, 'underlying abort() should be called while closing if underlying close() has not started yet');
502
503 promise_test(() => {
504 const ws = new WritableStream();
505 const writer = ws.getWriter();
506 return writer.ready.then(() => {
507 const closePromise = writer.close();
508 const abortPromise = writer.abort();
509 let closeResolved = false;
510 Promise.all([
511 closePromise.then(() => { closeResolved = true; }),
512 abortPromise.then(() => { assert_true(closeResolved, 'close() promise shou ld resolve before abort() promise'); })
513 ]);
514 });
515 }, 'writer close() promise should resolve before abort() promise');
516
517 promise_test(t => {
518 const ws = new WritableStream({
519 write(chunk, controller) {
520 controller.error(error1);
521 return new Promise(() => {});
522 }
523 });
524 const writer = ws.getWriter();
525 return writer.ready.then(() => {
526 writer.write('a');
527 return promise_rejects(t, error1, writer.ready, 'writer.ready should reject' );
528 });
529 }, 'writer.ready should reject on controller error without waiting for underlyin g write');
530
531 promise_test(t => {
532 let resolveWrite;
533 const ws = new WritableStream({
534 write() {
535 return new Promise(resolve => {
536 resolveWrite = resolve;
537 });
538 }
539 });
540 const writer = ws.getWriter();
541 return writer.ready.then(() => {
542 const writePromise = writer.write('a');
543 const closed = writer.closed;
544 const abortPromise = writer.abort();
545 writer.releaseLock();
546 resolveWrite();
547 return Promise.all([
548 writePromise,
549 abortPromise,
550 promise_rejects(t, new TypeError(), closed, 'closed should reject')]);
551 });
552 }, 'releaseLock() while aborting should reject the original closed promise');
553
554 promise_test(t => {
555 let resolveWrite;
556 let resolveAbort;
557 let resolveAbortStarted;
558 const abortStarted = new Promise(resolve => {
559 resolveAbortStarted = resolve;
560 });
561 const ws = new WritableStream({
562 write() {
563 return new Promise(resolve => {
564 resolveWrite = resolve;
565 });
566 },
567 abort() {
568 resolveAbortStarted();
569 return new Promise(resolve => {
570 resolveAbort = resolve;
571 });
572 }
573 });
574 const writer = ws.getWriter();
575 return writer.ready.then(() => {
576 const writePromise = writer.write('a');
577 const closed = writer.closed;
578 const abortPromise = writer.abort();
579 resolveWrite();
580 return abortStarted.then(() => {
581 writer.releaseLock();
582 assert_not_equals(writer.closed, closed, 'closed promise should have chang ed');
583 resolveAbort();
584 return Promise.all([
585 writePromise,
586 abortPromise,
587 promise_rejects(t, new TypeError(), closed, 'original closed should reje ct'),
588 promise_rejects(t, new TypeError(), writer.closed, 'new closed should re ject')]);
589 });
590 });
591 }, 'releaseLock() during delayed async abort() should create a new rejected clos ed promise');
592
593 done();
OLDNEW
« no previous file with comments | « third_party/WebKit/LayoutTests/external/wpt/streams/writable-streams/write.sharedworker-expected.txt ('k') | third_party/WebKit/LayoutTests/http/tests/streams/writable-streams/aborting.https.html » ('j') | third_party/WebKit/Source/core/streams/WritableStream.js » ('J')

Powered by Google App Engine
This is Rietveld 408576698