diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
commit | 26a029d407be480d791972afb5975cf62c9360a6 (patch) | |
tree | f435a8308119effd964b339f76abb83a57c29483 /testing/web-platform/tests/webtransport/streams-close.https.any.js | |
parent | Initial commit. (diff) | |
download | firefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz firefox-26a029d407be480d791972afb5975cf62c9360a6.zip |
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'testing/web-platform/tests/webtransport/streams-close.https.any.js')
-rw-r--r-- | testing/web-platform/tests/webtransport/streams-close.https.any.js | 252 |
1 files changed, 252 insertions, 0 deletions
diff --git a/testing/web-platform/tests/webtransport/streams-close.https.any.js b/testing/web-platform/tests/webtransport/streams-close.https.any.js new file mode 100644 index 0000000000..30b645a6a9 --- /dev/null +++ b/testing/web-platform/tests/webtransport/streams-close.https.any.js @@ -0,0 +1,252 @@ +// META: global=window,worker +// META: script=/common/get-host-info.sub.js +// META: script=/common/utils.js +// META: script=resources/webtransport-test-helpers.sub.js + +// Note: There is no aioquic event for STOP_SENDING yet, so the server does +// not support checking this yet. Hence, tests checking from the STOP_SENDING +// signal cannot be tested yet. + +promise_test(async t => { + const id = token(); + const wt = new WebTransport(webtransport_url(`client-close.py?token=${id}`)); + add_completion_callback(() => wt.close()); + await wt.ready; + + const bidi_stream = await wt.createBidirectionalStream(); + + const writable = bidi_stream.writable; + writable.close(); + + await wait(10); + const data = await query(id); + + assert_own_property(data, 'stream-close-info'); + const info = data['stream-close-info']; + + assert_equals(info.source, 'FIN', 'source'); +}, 'Close outgoing stream / bidi-1'); + +promise_test(async t => { + const id = token(); + const wt = new WebTransport(webtransport_url(`client-close.py?token=${id}`)); + add_completion_callback(() => wt.close()); + await wt.ready; + + const streams_reader = wt.incomingBidirectionalStreams.getReader(); + const {value: bidi} = await streams_reader.read(); + + const writable = bidi.writable; + writable.close(); + + await wait(10); + const data = await query(id); + + assert_own_property(data, 'stream-close-info'); + const info = data['stream-close-info']; + + assert_equals(info.source, 'FIN', 'source'); +}, 'Close outgoing stream / bidi-2'); + +promise_test(async t => { + const id = token(); + const wt = new WebTransport(webtransport_url(`client-close.py?token=${id}`)); + add_completion_callback(() => wt.close()); + await wt.ready; + + const writable = await wt.createUnidirectionalStream(); + writable.close(); + + await wait(10); + const data = await query(id); + + assert_own_property(data, 'stream-close-info'); + const info = data['stream-close-info']; + + assert_equals(info.source, 'FIN', 'source'); +}, 'Close outgoing stream / uni'); + +promise_test(async t => { + const id = token(); + const wt = new WebTransport(webtransport_url(`client-close.py?token=${id}`)); + add_completion_callback(() => wt.close()); + await wt.ready; + + const bidi_stream = await wt.createBidirectionalStream(); + + const writable = bidi_stream.writable; + + const WT_CODE = 139; + const HTTP_CODE = webtransport_code_to_http_code(WT_CODE); + await writable.abort( + new WebTransportError({streamErrorCode: WT_CODE})); + + await wait(10); + const data = await query(id); + + // Check that stream is aborted with RESET_STREAM with the code and reason + assert_own_property(data, 'stream-close-info'); + const info = data['stream-close-info']; + + assert_equals(info.source, 'reset', 'reset stream'); + assert_equals(info.code, HTTP_CODE, 'code'); +}, 'Abort client-created bidirectional stream'); + +promise_test(async t => { + const id = token(); + const wt = new WebTransport(webtransport_url(`client-close.py?token=${id}`)); + add_completion_callback(() => wt.close()); + await wt.ready; + + const stream_reader = wt.incomingBidirectionalStreams.getReader(); + const { value: bidi_stream } = await stream_reader.read(); + stream_reader.releaseLock(); + + const writer = bidi_stream.writable.getWriter(); + + const WT_CODE = 52; + const HTTP_CODE = webtransport_code_to_http_code(WT_CODE); + await writer.abort( + new WebTransportError({streamErrorCode: WT_CODE})); + + await wait(10); + const data = await query(id); + + // Check that stream is aborted with RESET_STREAM with the code and reason + assert_own_property(data, 'stream-close-info'); + const info = data['stream-close-info']; + + assert_equals(info.source, 'reset', 'reset_stream'); + assert_equals(info.code, HTTP_CODE, 'code'); +}, 'Abort server-initiated bidirectional stream'); + +promise_test(async t => { + const id = token(); + const wt = new WebTransport(webtransport_url(`client-close.py?token=${id}`)); + add_completion_callback(() => wt.close()); + await wt.ready; + + const writable = await wt.createUnidirectionalStream(); + + const WT_CODE = 95; + const HTTP_CODE = webtransport_code_to_http_code(WT_CODE); + await writable.abort( + new WebTransportError({streamErrorCode: WT_CODE})); + + await wait(10); + const data = await query(id); + + // Check that stream is aborted with RESET_STREAM with the code and reason + assert_own_property(data, 'stream-close-info'); + const info = data['stream-close-info']; + + assert_equals(info.source, 'reset', 'reset_stream'); + assert_equals(info.code, HTTP_CODE, 'code'); +}, 'Abort unidirectional stream with WebTransportError'); + +promise_test(async t => { + const id = token(); + const wt = new WebTransport(webtransport_url(`client-close.py?token=${id}`)); + add_completion_callback(() => wt.close()); + await wt.ready; + + const writable = await wt.createUnidirectionalStream(); + const writer = writable.getWriter(); + + const WT_CODE = 134; + const HTTP_CODE = webtransport_code_to_http_code(WT_CODE); + + // We use a large chunk so that sending the FIN signal takes time. + const chunk = new Uint8Array(64 * 1024); + const e = new WebTransportError({streamErrorCode: WT_CODE}); + // Write a chunk, close the stream, and then abort the stream immediately to + // abort the closing operation. + // TODO: Check that the abort promise is correctly rejected/resolved based on + // the spec discussion at https://github.com/whatwg/streams/issues/1203. + await writer.write(chunk); + const close_promise = writer.close(); + const abort_promise = writer.abort(e); + + await promise_rejects_exactly(t, e, close_promise, 'close_promise'); + await promise_rejects_exactly(t, e, writer.closed, '.closed'); + await promise_rejects_exactly(t, e, abort_promise, 'abort_promise'); + writer.releaseLock(); + + await wait(10); + const data = await query(id); + + // Check that stream is aborted with RESET_STREAM with the code and reason + assert_own_property(data, 'stream-close-info'); + const info = data['stream-close-info']; + + assert_equals(info.source, 'reset', 'reset_stream'); + assert_equals(info.code, HTTP_CODE, 'code'); +}, 'Close and abort unidirectional stream'); + +promise_test(async t => { + const id = token(); + const wt = new WebTransport(webtransport_url(`client-close.py?token=${id}`)); + add_completion_callback(() => wt.close()); + await wt.ready; + + const writable = await wt.createUnidirectionalStream(); + await writable.abort(); + + await wait(10); + const data = await query(id); + + // Check that stream is aborted with RESET_STREAM with the code and reason + assert_own_property(data, 'stream-close-info'); + const info = data['stream-close-info']; + + assert_equals(info.source, 'reset', 'reset_stream'); + assert_equals(info.code, webtransport_code_to_http_code(0), 'code'); +}, 'Abort unidirectional stream with default error code'); + +promise_test(async t => { + const WT_CODE = 0; + const HTTP_CODE = webtransport_code_to_http_code(WT_CODE); + const wt = new WebTransport( + webtransport_url(`abort-stream-from-server.py?code=${HTTP_CODE}`)); + add_completion_callback(() => wt.close()); + await wt.ready; + + const writable = await wt.createUnidirectionalStream(); + const writer = writable.getWriter(); + + // Write something, to make the stream visible to the server side. + await writer.write(new Uint8Array([64])); + + // Sadly we cannot use promise_rejects_dom as the error constructor is + // WebTransportError rather than DOMException. Ditto below. + // We get a possible error, and then make sure wt.closed is rejected with it. + const e = await writer.closed.catch(e => e); + await promise_rejects_exactly( + t, e, writer.closed, 'closed promise should be rejected'); + assert_true(e instanceof WebTransportError); + assert_equals(e.source, 'stream', 'source'); + assert_equals(e.streamErrorCode, WT_CODE, 'streamErrorCode'); +}, 'STOP_SENDING coming from server'); + +promise_test(async t => { + const WT_CODE = 0xffffffff; + const HTTP_CODE = webtransport_code_to_http_code(WT_CODE); + const wt = new WebTransport( + webtransport_url(`abort-stream-from-server.py?code=${HTTP_CODE}`)); + add_completion_callback(() => wt.close()); + await wt.ready; + + const bidi = await wt.createBidirectionalStream(); + const writer = bidi.writable.getWriter(); + + // Write something, to make the stream visible to the server side. + await writer.write(new Uint8Array([64])); + + const reader = bidi.readable.getReader(); + const e = await reader.closed.catch(e => e); + await promise_rejects_exactly( + t, e, reader.closed, 'closed promise should be rejected'); + assert_true(e instanceof WebTransportError); + assert_equals(e.source, 'stream', 'source'); + assert_equals(e.streamErrorCode, WT_CODE, 'streamErrorCode'); +}, 'RESET_STREAM coming from server'); |