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

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

Issue 2596883002: Update writable streams for the latest spec changes (Closed)
Patch Set: Fix nits with tests Created 3 years, 11 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 side-by-side diff with in-line comments
Download patch
Index: third_party/WebKit/LayoutTests/http/tests/streams/writable-streams/aborting.js
diff --git a/third_party/WebKit/LayoutTests/http/tests/streams/writable-streams/aborting.js b/third_party/WebKit/LayoutTests/http/tests/streams/writable-streams/aborting.js
index 3cf207cc5b911f076bf761ca4aebf0cd7bf76a39..87b25e72cb04b6ba7eacdf3220a79c7e5782e8be 100644
--- a/third_party/WebKit/LayoutTests/http/tests/streams/writable-streams/aborting.js
+++ b/third_party/WebKit/LayoutTests/http/tests/streams/writable-streams/aborting.js
@@ -9,6 +9,9 @@ if (self.importScripts) {
const error1 = new Error('error1');
error1.name = 'error1';
+const error2 = new Error('error2');
+error2.name = 'error2';
+
promise_test(t => {
const ws = new WritableStream({
write() {
@@ -17,7 +20,7 @@ promise_test(t => {
});
const writer = ws.getWriter();
- writer.write('a');
+ const writePromise = writer.write('a');
const readyPromise = writer.ready;
@@ -25,7 +28,10 @@ promise_test(t => {
assert_equals(writer.ready, readyPromise, 'the ready promise property should not change');
- return promise_rejects(t, new TypeError(), readyPromise, 'the ready promise should reject with a TypeError');
+ return Promise.all([
+ promise_rejects(t, new TypeError(), readyPromise, 'the ready promise should reject with a TypeError'),
+ promise_rejects(t, new TypeError(), writePromise, 'the write() promise should reject with a TypeError')
+ ]);
}, 'Aborting a WritableStream should cause the writer\'s unsettled ready promise to reject');
promise_test(t => {
@@ -53,7 +59,7 @@ promise_test(t => {
return promise_rejects(t, new TypeError(), writer.abort(), 'abort() should reject with a TypeError');
}, 'abort() on a released writer rejects');
-promise_test(() => {
+promise_test(t => {
const ws = recordingWritableStream();
return delay(0)
@@ -61,29 +67,43 @@ promise_test(() => {
const writer = ws.getWriter();
writer.abort();
- writer.write(1);
- writer.write(2);
+
+ return Promise.all([
+ promise_rejects(t, new TypeError(), writer.write(1), 'write(1) must reject with a TypeError'),
+ promise_rejects(t, new TypeError(), writer.write(2), 'write(2) must reject with a TypeError')
+ ]);
})
.then(() => {
assert_array_equals(ws.events, ['abort', undefined]);
});
}, 'Aborting a WritableStream immediately prevents future writes');
-promise_test(() => {
+promise_test(t => {
const ws = recordingWritableStream();
+ const results = [];
return delay(0)
.then(() => {
const writer = ws.getWriter();
- writer.write(1);
- writer.write(2);
- writer.write(3);
- writer.abort();
- writer.write(4);
- writer.write(5);
+ results.push(
+ writer.write(1),
+ promise_rejects(t, new TypeError(), writer.write(2), 'write(2) must reject with a TypeError'),
+ promise_rejects(t, new TypeError(), writer.write(3), 'write(3) must reject with a TypeError')
+ );
+
+ const abortPromise = writer.abort();
+
+ results.push(
+ promise_rejects(t, new TypeError(), writer.write(4), 'write(4) must reject with a TypeError'),
+ promise_rejects(t, new TypeError(), writer.write(5), 'write(5) must reject with a TypeError')
+ );
+
+ return abortPromise;
}).then(() => {
assert_array_equals(ws.events, ['write', 1, 'abort', undefined]);
+
+ return Promise.all(results);
});
}, 'Aborting a WritableStream prevents further writes after any that are in progress');
@@ -123,6 +143,32 @@ promise_test(t => {
'rejection reason of abortPromise must be the error thrown by abort');
}, 'WritableStream if sink\'s abort throws, the promise returned by ws.abort() rejects');
+promise_test(t => {
+ let resolveWritePromise;
+ const ws = new WritableStream({
+ write() {
+ return new Promise(resolve => {
+ resolveWritePromise = resolve;
+ });
+ },
+ abort() {
+ throw error1;
+ }
+ });
+
+ const writer = ws.getWriter();
+
+ writer.write().catch(() => {});
+ return flushAsyncEvents().then(() => {
+ const abortPromise = writer.abort(undefined);
+
+ resolveWritePromise();
+ return promise_rejects(t, error1, abortPromise,
+ 'rejection reason of abortPromise must be the error thrown by abort');
+ });
+}, 'WritableStream if sink\'s abort throws, for an abort performed during a write, the promise returned by ' +
+ 'ws.abort() rejects');
+
test(() => {
const ws = recordingWritableStream();
const writer = ws.getWriter();
@@ -162,26 +208,36 @@ promise_test(t => {
const ws = new WritableStream();
const writer = ws.getWriter();
- writer.close();
+ const closePromise = writer.close();
writer.abort(error1);
- return promise_rejects(t, new TypeError(), writer.closed, 'closed should reject with a TypeError');
+ return Promise.all([
+ promise_rejects(t, new TypeError(), writer.closed, 'closed should reject with a TypeError'),
+ promise_rejects(t, new TypeError(), closePromise, 'close() should reject with a TypeError')
+ ]);
}, 'Closing but then immediately aborting a WritableStream causes the stream to error');
promise_test(t => {
+ let resolveClose;
const ws = new WritableStream({
close() {
- return new Promise(() => { }); // forever-pending
+ return new Promise(resolve => {
+ resolveClose = resolve;
+ });
}
});
const writer = ws.getWriter();
- writer.close();
+ const closePromise = writer.close();
return delay(0).then(() => {
writer.abort(error1);
- })
- .then(() => promise_rejects(t, new TypeError(), writer.closed, 'closed should reject with a TypeError'));
+ resolveClose();
+ return Promise.all([
+ promise_rejects(t, new TypeError(), writer.closed, 'closed should reject with a TypeError'),
+ closePromise
+ ]);
+ });
}, 'Closing a WritableStream and aborting it while it closes causes the stream to error');
promise_test(() => {
@@ -193,14 +249,25 @@ promise_test(() => {
return delay(0).then(() => writer.abort());
}, 'Aborting a WritableStream after it is closed is a no-op');
-test(() => {
- const ws = recordingWritableStream();
+promise_test(t => {
+ // Cannot use recordingWritableStream since it always has an abort
+ let controller;
+ let closeArgs;
+ const ws = new WritableStream({
+ start(c) {
+ controller = c;
+ },
+ close(...args) {
+ closeArgs = args;
+ }
+ });
+
const writer = ws.getWriter();
writer.abort();
- return writer.closed.then(() => {
- assert_array_equals(ws.events, ['close']);
+ return promise_rejects(t, new TypeError(), writer.closed, 'closed should reject with a TypeError').then(() => {
+ assert_array_equals(closeArgs, [controller], 'close must have been called, with the controller as its argument');
});
}, 'WritableStream should call underlying sink\'s close if no abort is supplied');
@@ -220,4 +287,308 @@ promise_test(() => {
return writer.abort().then(() => assert_true(thenCalled, 'then() should be called'));
}, 'returning a thenable from abort() should work');
+promise_test(t => {
+ const ws = new WritableStream({
+ write() {
+ return flushAsyncEvents();
+ }
+ });
+ const writer = ws.getWriter();
+ return writer.ready.then(() => {
+ const writePromise = writer.write('a');
+ writer.abort(error1);
+ let closedResolved = false;
+ return Promise.all([
+ writePromise.then(() => assert_false(closedResolved, '.closed should not resolve before write()')),
+ promise_rejects(t, new TypeError(), writer.closed, '.closed should reject').then(() => {
+ closedResolved = true;
+ })
+ ]);
+ });
+}, '.closed should not resolve before fulfilled write()');
+
+promise_test(t => {
+ const ws = new WritableStream({
+ write() {
+ return Promise.reject(error1);
+ }
+ });
+ const writer = ws.getWriter();
+ return writer.ready.then(() => {
+ const writePromise = writer.write('a');
+ const abortPromise = writer.abort(error2);
+ let closedResolved = false;
+ return Promise.all([
+ promise_rejects(t, error1, writePromise, 'write() should reject')
+ .then(() => assert_false(closedResolved, '.closed should not resolve before write()')),
+ promise_rejects(t, error1, writer.closed, '.closed should reject')
+ .then(() => {
+ closedResolved = true;
+ }),
+ promise_rejects(t, error1, abortPromise, 'abort() should reject')]);
+ });
+}, '.closed should not resolve before rejected write(); write() error should overwrite abort() error');
+
+promise_test(t => {
+ const ws = new WritableStream({
+ write() {
+ return flushAsyncEvents();
+ }
+ }, new CountQueuingStrategy(4));
+ const writer = ws.getWriter();
+ return writer.ready.then(() => {
+ const settlementOrder = [];
+ return Promise.all([
+ writer.write('1').then(() => settlementOrder.push(1)),
+ promise_rejects(t, new TypeError(), writer.write('2'), 'first queued write should be rejected')
+ .then(() => settlementOrder.push(2)),
+ promise_rejects(t, new TypeError(), writer.write('3'), 'second queued write should be rejected')
+ .then(() => settlementOrder.push(3)),
+ writer.abort(error1)
+ ]).then(() => assert_array_equals([1, 2, 3], settlementOrder, 'writes should be satisfied in order'));
+ });
+}, 'writes should be satisfied in order when aborting');
+
+promise_test(t => {
+ const ws = new WritableStream({
+ write() {
+ return Promise.reject(error1);
+ }
+ }, new CountQueuingStrategy(4));
+ const writer = ws.getWriter();
+ return writer.ready.then(() => {
+ const settlementOrder = [];
+ return Promise.all([
+ promise_rejects(t, error1, writer.write('1'), 'pending write should be rejected')
+ .then(() => settlementOrder.push(1)),
+ promise_rejects(t, error1, writer.write('2'), 'first queued write should be rejected')
+ .then(() => settlementOrder.push(2)),
+ promise_rejects(t, error1, writer.write('3'), 'second queued write should be rejected')
+ .then(() => settlementOrder.push(3)),
+ promise_rejects(t, error1, writer.abort(error1), 'abort should be rejected')
+ ]).then(() => assert_array_equals([1, 2, 3], settlementOrder, 'writes should be satisfied in order'));
+ });
+}, 'writes should be satisfied in order after rejected write when aborting');
+
+promise_test(t => {
+ const ws = new WritableStream({
+ write() {
+ return Promise.reject(error1);
+ }
+ });
+ const writer = ws.getWriter();
+ return writer.ready.then(() => {
+ return Promise.all([
+ promise_rejects(t, error1, writer.write('a'), 'writer.write() should reject with error from underlying write()'),
+ promise_rejects(t, error1, writer.close(), 'writer.close() should reject with error from underlying write()'),
+ promise_rejects(t, error1, writer.abort(), 'writer.abort() should reject with error from underlying write()')
+ ]);
+ });
+}, 'close() should use error from underlying write() on abort');
+
+promise_test(() => {
+ let resolveWrite;
+ let abortCalled = false;
+ const ws = new WritableStream({
+ write() {
+ return new Promise(resolve => {
+ resolveWrite = resolve;
+ });
+ },
+ abort() {
+ abortCalled = true;
+ }
+ });
+
+ const writer = ws.getWriter();
+ return writer.ready.then(() => {
+ writer.write('a');
+ const abortPromise = writer.abort();
+ return flushAsyncEvents().then(() => {
+ assert_false(abortCalled, 'abort should not be called while write is pending');
+ resolveWrite();
+ return abortPromise.then(() => assert_true(abortCalled, 'abort should be called'));
+ });
+ });
+}, 'underlying abort() should not be called until underlying write() completes');
+
+promise_test(() => {
+ let resolveClose;
+ let abortCalled = false;
+ const ws = new WritableStream({
+ close() {
+ return new Promise(resolve => {
+ resolveClose = resolve;
+ });
+ },
+ abort() {
+ abortCalled = true;
+ }
+ });
+
+ const writer = ws.getWriter();
+ return writer.ready.then(() => {
+ writer.close();
+ const abortPromise = writer.abort();
+ return flushAsyncEvents().then(() => {
+ assert_false(abortCalled, 'underlying abort should not be called while close is pending');
+ resolveClose();
+ return abortPromise.then(() => {
+ assert_false(abortCalled, 'underlying abort should not be called after close completes');
+ });
+ });
+ });
+}, 'underlying abort() should not be called if underlying close() has started');
+
+promise_test(t => {
+ let rejectClose;
+ let abortCalled = false;
+ const ws = new WritableStream({
+ close() {
+ return new Promise((resolve, reject) => {
+ rejectClose = reject;
+ });
+ },
+ abort() {
+ abortCalled = true;
+ }
+ });
+
+ const writer = ws.getWriter();
+ return writer.ready.then(() => {
+ const closePromise = writer.close();
+ const abortPromise = writer.abort();
+ return flushAsyncEvents().then(() => {
+ assert_false(abortCalled, 'underlying abort should not be called while close is pending');
+ rejectClose(error1);
+ return promise_rejects(t, error1, abortPromise, 'abort should reject with the same reason').then(() => {
+ return promise_rejects(t, error1, closePromise, 'close should reject with the same reason');
+ }).then(() => {
+ assert_false(abortCalled, 'underlying abort should not be called after close completes');
+ });
+ });
+ });
+}, 'if underlying close() has started and then rejects, the abort() and close() promises should reject with the ' +
+ 'underlying close rejection reason');
+
+promise_test(t => {
+ let resolveWrite;
+ let abortCalled = false;
+ const ws = new WritableStream({
+ write() {
+ return new Promise(resolve => {
+ resolveWrite = resolve;
+ });
+ },
+ abort() {
+ abortCalled = true;
+ }
+ });
+
+ const writer = ws.getWriter();
+ return writer.ready.then(() => {
+ writer.write('a');
+ const closePromise = writer.close();
+ const abortPromise = writer.abort();
+ return flushAsyncEvents().then(() => {
+ assert_false(abortCalled, 'abort should not be called while write is pending');
+ resolveWrite();
+ return abortPromise.then(() => {
+ assert_true(abortCalled, 'abort should be called after write completes');
+ return promise_rejects(t, new TypeError(), closePromise, 'promise returned by close() should be rejected');
+ });
+ });
+ });
+}, 'underlying abort() should be called while closing if underlying close() has not started yet');
+
+promise_test(() => {
+ const ws = new WritableStream();
+ const writer = ws.getWriter();
+ return writer.ready.then(() => {
+ const closePromise = writer.close();
+ const abortPromise = writer.abort();
+ let closeResolved = false;
+ Promise.all([
+ closePromise.then(() => { closeResolved = true; }),
+ abortPromise.then(() => { assert_true(closeResolved, 'close() promise should resolve before abort() promise'); })
+ ]);
+ });
+}, 'writer close() promise should resolve before abort() promise');
+
+promise_test(t => {
+ const ws = new WritableStream({
+ write(chunk, controller) {
+ controller.error(error1);
+ return new Promise(() => {});
+ }
+ });
+ const writer = ws.getWriter();
+ return writer.ready.then(() => {
+ writer.write('a');
+ return promise_rejects(t, error1, writer.ready, 'writer.ready should reject');
+ });
+}, 'writer.ready should reject on controller error without waiting for underlying write');
+
+promise_test(t => {
+ let resolveWrite;
+ const ws = new WritableStream({
+ write() {
+ return new Promise(resolve => {
+ resolveWrite = resolve;
+ });
+ }
+ });
+ const writer = ws.getWriter();
+ return writer.ready.then(() => {
+ const writePromise = writer.write('a');
+ const closed = writer.closed;
+ const abortPromise = writer.abort();
+ writer.releaseLock();
+ resolveWrite();
+ return Promise.all([
+ writePromise,
+ abortPromise,
+ promise_rejects(t, new TypeError(), closed, 'closed should reject')]);
+ });
+}, 'releaseLock() while aborting should reject the original closed promise');
+
+promise_test(t => {
+ let resolveWrite;
+ let resolveAbort;
+ let resolveAbortStarted;
+ const abortStarted = new Promise(resolve => {
+ resolveAbortStarted = resolve;
+ });
+ const ws = new WritableStream({
+ write() {
+ return new Promise(resolve => {
+ resolveWrite = resolve;
+ });
+ },
+ abort() {
+ resolveAbortStarted();
+ return new Promise(resolve => {
+ resolveAbort = resolve;
+ });
+ }
+ });
+ const writer = ws.getWriter();
+ return writer.ready.then(() => {
+ const writePromise = writer.write('a');
+ const closed = writer.closed;
+ const abortPromise = writer.abort();
+ resolveWrite();
+ return abortStarted.then(() => {
+ writer.releaseLock();
+ assert_not_equals(writer.closed, closed, 'closed promise should have changed');
+ resolveAbort();
+ return Promise.all([
+ writePromise,
+ abortPromise,
+ promise_rejects(t, new TypeError(), closed, 'original closed should reject'),
+ promise_rejects(t, new TypeError(), writer.closed, 'new closed should reject')]);
+ });
+ });
+}, 'releaseLock() during delayed async abort() should create a new rejected closed promise');
+
done();

Powered by Google App Engine
This is Rietveld 408576698