Bug 1738030 [wpt PR 31400] - Streams: Add/update WPTs with AbortSigna…

…l's abort reason, a=testonly Automatic update from web-platform-tests Streams: Update WPTs with AbortSignal.reason (#31400) See whatwg/streams#1182 for the accompanying spec change. -- wpt-commits: b724cac4269298cfa57064bd5751e7e6e7593727 wpt-pr: 31400
jamienicol · Nov 12, 2021 · 89de22d · 89de22d
1 parent f281ef0
commit 89de22d
Show file tree

Hide file tree

Showing 2 changed files with 87 additions and 70 deletions.
diff --git a/testing/web-platform/tests/streams/piping/abort.any.js b/testing/web-platform/tests/streams/piping/abort.any.js
@@ -53,29 +53,28 @@ promise_test(t => {
  });
 }, 'an aborted signal should cause the writable stream to reject with an AbortError');
 
-promise_test(() => {
- let error;
- const rs = recordingReadableStream(errorOnPull, hwm0);
- const ws = new WritableStream();
- const abortController = new AbortController();
- const signal = abortController.signal;
- abortController.abort();
- return rs.pipeTo(ws, { signal })
- .catch(e => {
- error = e;
- })
- .then(() => Promise.all([
- rs.getReader().closed,
- ws.getWriter().closed.catch(e => {
- assert_equals(e, error, 'the writable should be errored with the same object');
- })
- ]))
- .then(() => {
+for (const reason of [null, undefined, error1]) {
+ promise_test(async t => {
+ const rs = recordingReadableStream(errorOnPull, hwm0);
+ const ws = new WritableStream();
+ const abortController = new AbortController();
+ const signal = abortController.signal;
+ abortController.abort(reason);
+ const pipeToPromise = rs.pipeTo(ws, { signal });
+ if (reason === error1) {
+ await promise_rejects_exactly(t, error1, pipeToPromise, 'pipeTo rejects with abort reason');
+ } else {
+ await promise_rejects_dom(t, 'AbortError', pipeToPromise, 'pipeTo rejects with AbortError');
+ }
+ const error = await pipeToPromise.catch(e => e);
+ await rs.getReader().closed;
+ await promise_rejects_exactly(t, error, ws.getWriter().closed, 'the writable should be errored with the same object');
+ assert_equals(signal.reason, error, 'signal.reason should be error'),
  assert_equals(rs.events.length, 2, 'cancel should have been called');
  assert_equals(rs.events[0], 'cancel', 'first event should be cancel');
  assert_equals(rs.events[1], error, 'the readable should be canceled with the same object');
- });
-}, 'all the AbortError objects should be the same object');
+ }, `(reason: '${reason}') all the error objects should be the same object`);
+}
 
 promise_test(t => {
  const rs = recordingReadableStream(errorOnPull, hwm0);
@@ -115,61 +114,74 @@ promise_test(t => {
  });
 }, 'preventCancel and preventAbort should prevent canceling the readable and aborting the readable');
 
-promise_test(t => {
- const rs = new ReadableStream({
- start(controller) {
- controller.enqueue('a');
- controller.enqueue('b');
- controller.close();
- }
- });
- const abortController = new AbortController();
- const signal = abortController.signal;
- const ws = recordingWritableStream({
- write() {
- abortController.abort();
+for (const reason of [null, undefined, error1]) {
+ promise_test(async t => {
+ const rs = new ReadableStream({
+ start(controller) {
+ controller.enqueue('a');
+ controller.enqueue('b');
+ controller.close();
+ }
+ });
+ const abortController = new AbortController();
+ const signal = abortController.signal;
+ const ws = recordingWritableStream({
+ write() {
+ abortController.abort(reason);
+ }
+ });
+ const pipeToPromise = rs.pipeTo(ws, { signal });
+ if (reason === error1) {
+ await promise_rejects_exactly(t, error1, pipeToPromise, 'pipeTo rejects with abort reason');
+ } else {
+ await promise_rejects_dom(t, 'AbortError', pipeToPromise, 'pipeTo rejects with AbortError');
  }
- });
- return promise_rejects_dom(t, 'AbortError', rs.pipeTo(ws, { signal }), 'pipeTo should reject')
- .then(() => {
- assert_equals(ws.events.length, 4, 'only chunk "a" should have been written');
- assert_array_equals(ws.events.slice(0, 3), ['write', 'a', 'abort'], 'events should match');
- assert_equals(ws.events[3].name, 'AbortError', 'abort reason should be an AbortError');
- });
-}, 'abort should prevent further reads');
+ const error = await pipeToPromise.catch(e => e);
+ assert_equals(signal.reason, error, 'signal.reason should be error');
+ assert_equals(ws.events.length, 4, 'only chunk "a" should have been written');
+ assert_array_equals(ws.events.slice(0, 3), ['write', 'a', 'abort'], 'events should match');
+ assert_equals(ws.events[3], error, 'abort reason should be error');
+ }, `(reason: '${reason}') abort should prevent further reads`);
+}
 
-promise_test(t => {
- let readController;
- const rs = new ReadableStream({
- start(c) {
- readController = c;
- c.enqueue('a');
- c.enqueue('b');
- }
- });
- const abortController = new AbortController();
- const signal = abortController.signal;
- let resolveWrite;
- const writePromise = new Promise(resolve => {
- resolveWrite = resolve;
- });
- const ws = recordingWritableStream({
- write() {
- return writePromise;
+for (const reason of [null, undefined, error1]) {
+ promise_test(async t => {
+ let readController;
+ const rs = new ReadableStream({
+ start(c) {
+ readController = c;
+ c.enqueue('a');
+ c.enqueue('b');
+ }
+ });
+ const abortController = new AbortController();
+ const signal = abortController.signal;
+ let resolveWrite;
+ const writePromise = new Promise(resolve => {
+ resolveWrite = resolve;
+ });
+ const ws = recordingWritableStream({
+ write() {
+ return writePromise;
+ }
+ }, new CountQueuingStrategy({ highWaterMark: Infinity }));
+ const pipeToPromise = rs.pipeTo(ws, { signal });
+ await delay(0);
+ await abortController.abort(reason);
+ await readController.close(); // Make sure the test terminates when signal is not implemented.
+ await resolveWrite();
+ if (reason === error1) {
+ await promise_rejects_exactly(t, error1, pipeToPromise, 'pipeTo rejects with abort reason');
+ } else {
+ await promise_rejects_dom(t, 'AbortError', pipeToPromise, 'pipeTo rejects with AbortError');
  }
- }, new CountQueuingStrategy({ highWaterMark: Infinity }));
- const pipeToPromise = rs.pipeTo(ws, { signal });
- return delay(0).then(() => {
- abortController.abort();
- readController.close(); // Make sure the test terminates when signal is not implemented.
- resolveWrite();
- return promise_rejects_dom(t, 'AbortError', pipeToPromise, 'pipeTo should reject');
- }).then(() => {
+ const error = await pipeToPromise.catch(e => e);
+ assert_equals(signal.reason, error, 'signal.reason should be error');
  assert_equals(ws.events.length, 6, 'chunks "a" and "b" should have been written');
  assert_array_equals(ws.events.slice(0, 5), ['write', 'a', 'write', 'b', 'abort'], 'events should match');
- assert_equals(ws.events[5].name, 'AbortError', 'abort reason should be an AbortError');
- });
-}, 'all pending writes should complete on abort');
+ assert_equals(ws.events[5], error, 'abort reason should be error');
+ }, `(reason: '${reason}') all pending writes should complete on abort`);
+}
 
 promise_test(t => {
  const rs = new ReadableStream({

diff --git a/testing/web-platform/tests/streams/writable-streams/aborting.any.js b/testing/web-platform/tests/streams/writable-streams/aborting.any.js
@@ -1384,8 +1384,10 @@ test(t => {
 
  assert_true(ctrl.signal instanceof AbortSignal);
  assert_false(ctrl.signal.aborted);
+ assert_equals(ctrl.signal.reason, undefined, 'signal.reason before abort');
  ws.abort(e);
  assert_true(ctrl.signal.aborted);
+ assert_equals(ctrl.signal.reason, e);
 }, 'WritableStreamDefaultController.signal');
 
 promise_test(async t => {
@@ -1403,8 +1405,11 @@ promise_test(async t => {
  await called;
 
  assert_false(ctrl.signal.aborted);
+ assert_equals(ctrl.signal.reason, undefined, 'signal.reason before abort');
  writer.abort();
  assert_true(ctrl.signal.aborted);
+ assert_true(ctrl.signal.reason instanceof DOMException, 'signal.reason is a DOMException');
+ assert_equals(ctrl.signal.reason.name, 'AbortError', 'signal.reason is an AbortError');
 }, 'the abort signal is signalled synchronously - write');
 
 promise_test(async t => {