@fails-components/webtransport 1.0.8 → 1.0.9

package/lib/session.js

@@ -22,6 +22,7 @@ const log = logger(`webtransport:httpwtsession(${pid})`)
  * @typedef {import('./dom').WebTransportCloseInfo} WebTransportCloseInfo
  * @typedef {import('./dom').WebTransportBidirectionalStream} WebTransportBidirectionalStream
  * @typedef {import('./dom').WebTransportSendStream} WebTransportSendStream
+ * @typedef {import('./dom').WebTransportSendStreamOptions} WebTransportSendStreamOptions
  * @typedef {import('./dom').WebTransportReceiveStream} WebTransportReceiveStream
  * @typedef {import('./dom').WebTransportDatagramDuplexStream} WebTransportDatagramDuplexStream
  * @typedef {import('./dom').WebTransportReliabilityMode} WebTransportReliabilityMode
@@ -199,6 +200,9 @@ export class HttpWTSession {
       this.objint = object
       this.objint.jsobj = this
       this.reliable = !!reliable
+      if (this.objint.sendInitialParameters) {
+        this.objint.sendInitialParameters()
+      }
     }
   }
 
@@ -339,9 +343,10 @@ export class HttpWTSession {
   }
 
   /**
+   * @param {WebTransportSendStreamOptions} [opts]
    * @returns {Promise<WebTransportBidirectionalStream>}
    */
-  createBidirectionalStream() {
+  createBidirectionalStream(opts) {
     if (this.objint == null) {
       throw new Error('this.objint not set')
     }
@@ -350,14 +355,25 @@ export class HttpWTSession {
       this.resolveBiDi.push(resolve)
       this.rejectBiDi.push(reject)
     })
-    this.objint.orderBidiStream()
+    const notblocked = this.objint.orderBidiStream({
+      sendGroup: opts?.sendGroup || null, // maybe replace, when implemented
+      sendOrder: opts?.sendOrder || 0,
+      waitUntilAvailable: opts?.waitUntilAvailable || false
+    })
+    if (!notblocked) {
+      const rej = this.rejectBiDi.pop()
+      this.resolveBiDi.pop()
+      if (rej)
+        rej(new DOMException('No streams available', 'QuotaExceededError'))
+    }
     return prom
   }
 
   /**
-   *@returns {Promise<WebTransportSendStream>}
+   * @param {WebTransportSendStreamOptions} [opts]
+   * @returns {Promise<WebTransportSendStream>}
    */
-  createUnidirectionalStream() {
+  createUnidirectionalStream(opts) {
     if (this.objint == null) {
       throw new Error('this.objint not set')
     }
@@ -366,7 +382,17 @@ export class HttpWTSession {
       this.resolveUniDi.push(resolve)
       this.rejectUniDi.push(reject)
     })
-    this.objint.orderUnidiStream()
+    const notblocked = this.objint.orderUnidiStream({
+      sendGroup: opts?.sendGroup || null, // maybe replace, when implemented
+      sendOrder: opts?.sendOrder || 0,
+      waitUntilAvailable: opts?.waitUntilAvailable || false
+    })
+    if (!notblocked) {
+      const rej = this.rejectUniDi.pop()
+      this.resolveUniDi.pop()
+      if (rej)
+        rej(new DOMException('No streams available', 'QuotaExceededError'))
+    }
     return prom
   }
 

package/lib/types.ts

@@ -1,7 +1,8 @@
 import type {
   WebTransportSession,
   WebTransportHash,
-  WebTransportOptions
+  WebTransportOptions,
+  WebTransportSendGroup
 } from './dom'
 import type { IncomingHttpHeaders, Http2Stream } from 'http2'
 import { ParserBase } from './http2/parserbase'
@@ -15,8 +16,8 @@ export interface NativeHttpWTSession {
   jsobj: WebTransportSessionEventHandler
   sendInitialParameters?: () => void
   writeDatagram: (chunk: Uint8Array) => void
-  orderUnidiStream: () => void
-  orderBidiStream: () => void
+  orderUnidiStream: (opts:{sendGroup:  WebTransportSendGroup|null, sendOrder: number, waitUntilAvailable: boolean}) => boolean
+  orderBidiStream: (opts:{sendGroup:  WebTransportSendGroup|null, sendOrder: number, waitUntilAvailable: boolean})  => boolean
   orderSessionStats: () => void
   orderDatagramStats: () => void
   notifySessionDraining: () => void
@@ -47,12 +48,18 @@ export interface NativeServerOptions {
   certhttp2?: string // if http2 has a different cert
   privKey: string
   privKeyhttp2?: string // if http2 has a different cert
+  initialBidirectionalSendStreams?: number
+  initialBidirectionalReceiveStreams?: number
+  initialUnidirectionalSendStreams?: number
+  initialUnidirectionalReceiveStreams?: number
   initialStreamFlowControlWindow?: number
   streamShouldAutoTuneReceiveWindow?: boolean
   streamFlowControlWindowSizeLimit?: number
   initialSessionFlowControlWindow?: number
   sessionShouldAutoTuneReceiveWindow?: boolean
   sessionFlowControlWindowSizeLimit?: number
+  initialBidirectionalStreams?: number
+  initialUnidirectionalStreams?: number
 }
 
 export interface NativeClientOptions {
@@ -62,6 +69,10 @@ export interface NativeClientOptions {
   localPort: number
   allowPooling: boolean
   forceIpv6: boolean
+  initialBidirectionalSendStreams?: number
+  initialBidirectionalReceiveStreams?: number
+  initialUnidirectionalSendStreams?: number
+  initialUnidirectionalReceiveStreams?: number
   initialStreamFlowControlWindow?: number
   streamShouldAutoTuneReceiveWindow?: boolean
   streamFlowControlWindowSizeLimit?: number
@@ -78,6 +89,11 @@ export interface FlowControlable {
   smoothedRtt: () => number
 }
 
+export interface StreamIdClient {
+  canSendMaxStreams: () => boolean
+  sendMaxStreams: (maxStreams: bigint, unidirectional: boolean) => void
+}
+
 export interface ReadBuffer {
   buffer?: Uint8Array
   readBytes?: number
@@ -330,6 +346,6 @@ export interface ParserWebsocketInit extends ParserInit {
 }
 
 export interface ReadDataInt {
-  data: Uint8Array
+  data: Uint8Array|undefined
   fin: boolean
 }

package/lib/webtransport.browser.js

@@ -10,6 +10,8 @@ const log = logger(`webtransport:browser()`)
  * @typedef {import('./dom').WebTransport} WebTransport
  * @typedef {import('./dom').WebTransportCloseInfo} WebTransportCloseInfo
  * @typedef {import('./dom').WebTransportBidirectionalStream} WebTransportBidirectionalStream
+ * @typedef {import('./dom').WebTransportSendStream} WebTransportSendStream
+ * @typedef {import('./dom').WebTransportSendStreamOptions} WebTransportSendStreamOptions
  * @typedef {import('./dom').WebTransportReceiveStream} WebTransportReceiveStream
  * @typedef {import('./error').WebTransportError} WebTransportError
  */
@@ -307,13 +309,21 @@ export class WebTransportPolyfill {
     this.curtransport.close(closeinfo)
   }
 
-  async createBidirectionalStream() {
+  /**
+   * @param {WebTransportSendStreamOptions} [opts]
+   * @returns {Promise<WebTransportBidirectionalStream>}
+   */
+  async createBidirectionalStream(opts) {
     await this.ready
-    return await this.curtransport.createBidirectionalStream()
+    return await this.curtransport.createBidirectionalStream(opts)
   }
 
-  async createUnidirectionalStream() {
+  /**
+   * @param {WebTransportSendStreamOptions} [opts]
+   * @returns {Promise<WebTransportSendStream>}
+   */
+  async createUnidirectionalStream(opts) {
     await this.ready
-    return await this.curtransport.createUnidirectionalStream()
+    return await this.curtransport.createUnidirectionalStream(opts)
   }
 }

package/lib/webtransportbase.js

@@ -4,6 +4,8 @@
  * @typedef {import('./dom.js').WebTransportCloseInfo} WebTransportCloseInfo
  * @typedef {import('./dom.js').WebTransportBidirectionalStream} WebTransportBidirectionalStream
  * @typedef {import('./dom.js').WebTransportReceiveStream} WebTransportReceiveStream
+ * @typedef {import('./dom.js').WebTransportSendStream} WebTransportSendStream
+ * @typedef {import('./dom.js').WebTransportSendStreamOptions} WebTransportSendStreamOptions
  * @typedef {import('./session.js').HttpWTSession} HttpWTSession
  * @typedef { import('./session.js').HttpClient} HttpClient
  */
@@ -119,7 +121,11 @@ export class WebTransportBase {
     return session.close(closeinfo)
   }
 
-  createBidirectionalStream() {
+  /**
+   * @param {WebTransportSendStreamOptions} [opts]
+   * @returns {Promise<WebTransportBidirectionalStream>}
+   */
+  createBidirectionalStream(opts) {
     const session = this.sessionint
 
     if (!session) {
@@ -127,10 +133,14 @@ export class WebTransportBase {
       throw new Error('Http3WTSession was undefined')
     }
 
-    return session.createBidirectionalStream()
+    return session.createBidirectionalStream(opts)
   }
 
-  createUnidirectionalStream() {
+  /**
+   * @param {WebTransportSendStreamOptions} [opts]
+   * @returns {Promise<WebTransportSendStream>}
+   */
+  createUnidirectionalStream(opts) {
     const session = this.sessionint
 
     if (!session) {
@@ -138,6 +148,6 @@ export class WebTransportBase {
       throw new Error('Http3WTSession was undefined')
     }
 
-    return session.createUnidirectionalStream()
+    return session.createUnidirectionalStream(opts)
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fails-components/webtransport",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "A component to add webtransport support (server and client) to node.js using libquiche",
   "exports": {
     ".": {

package/readme.md

@@ -23,8 +23,6 @@ Note, that the client implementation only supports certificate checking via `cer
 It may be possible in the future to also support normal HTTP/3 with not so much effort, however, there is no intention from the author to implement this since it will not be needed by FAILS. However, PR requests are welcome and will be supported by advice from the author.
 The package for the HTTP/3 should be considered as a duct tape-style solution until a bulletproof native support of HTTP/3 and WebTransport is provided by node itself.
 
-If you need a ponyfill check out the sister package [https://github.com/fails-components/webtransport-ponyfill-websocket/](https://github.com/fails-components/webtransport-ponyfill-websocket/), which provides a mapping of the Webtransport interfaces to Websocket connections.
-
 ## Changes for Version 1.x.x
 
 The interface for version 1.x.x is not changed compared to 0.x.x.
@@ -37,12 +35,15 @@ Note, that it is only partially implemented and also some http2 features require
 Use for the server side either `HttpServer` for http/2 and http/3 support (including WebTransport over WebSocket), Http3Server for http/3 only and Http2Server for http/2 only.
 For the client side pass the options `forceReliable`, `requireUnreliable` etc. to force/select a type of transport.
 
- **Note, that the http/2 webtransport protocol (not supported by any browser yet), is implemented without the support of receiving initial settings, which can cause a problem with the initial flow control of the WebTransport streams. This is a current limitation in node.js. Note, that for sending the required initial setting you need a very recent (unreleased) version of node.js.** This limitation does not apply to the polyfill/ponyfill and the websocket protocol.
+ **Note, that the http/2 webtransport protocol (not supported by any browser yet), is implemented without the support of receiving initial settings, which can cause a problem with the initial flow control of the WebTransport streams. This is a current limitation in node.js, but a patch to add support will soon be part of new node versions. Note, that for sending the required initial setting you need a very recent version (>=21.6.1) of node.js.** This limitation does not apply to the polyfill/ponyfill and the webtransport over websocket protocol.
+
+ The current proposal for the WebTransport over WebSocket protocol can be found [here] (https://datatracker.ietf.org/doc/draft-richter-webtransport-websocket/).
 
 ### Ponyfill/Polyfill
 Together with an experimental http/2 implementation of WebTransport, the underlying http/2 capsule protocol had been mapped to the WebSocket protocol, so that the packages can also be used as a ponyfill/polyfill on the browser side.
 Please use `WebTransportPonyfill` for a WebSocket only or `WebTransportPolyfill` as a replacement for `WebTransport`, which automatically falls back to the browser's implementation, if the corresponding features are natively supported in the browser.
 
+The used WebSocket protocol is currently proprietary and described in detail [here](https://martenrichter.github.io/draft-ietf-webtransport-websocket/draft-richter-webtransport-websocket.html). 
 
 ## Installation and usage
 

package/test/fixtures/certificate.js

@@ -381,7 +381,7 @@ export async function generateWebTransportCertificate(attrs, options) {
       options.extensions || [
         {
           name: 'basicConstraints',
-          cA: true
+          cA: false
         },
         {
           name: 'keyUsage',
@@ -428,7 +428,6 @@ export async function generateWebTransportCertificate(attrs, options) {
     cert.signature = await cert.signature
 
     const pemcert = pki.certificateToPem(cert)
-
     const x509cert = new X509Certificate(pemcert)
 
     const certhash = Buffer.from(

package/test/fixtures/server.js

@@ -39,7 +39,7 @@ export async function createServer() {
   } else {
     server = new Http3Server({
       /*   port: 8080,
-    host: '0.0.0.0', */
+      host: '0.0.0.0', */
       port: 0,
       host: '127.0.0.1',
       secret: 'mysecret',
@@ -48,10 +48,15 @@ export async function createServer() {
     })
   }
 
+  let adjustlimit = 1
+  if (process.env.USE_HTTP2 === 'true') {
+    adjustlimit = 0
+  }
+
   server.ready
     .then(async () => {
       // set up listeners for the different server paths used by the tests
-
+      console.log('server ready')
       await Promise.all(
         [
           // echo server, initiated by remote
@@ -162,6 +167,104 @@ export async function createServer() {
             }
           },
 
+          // receive 100+ bidi streams and block
+          async () => {
+            for await (const session of getReaderStream(
+              server.sessionStream('/streamlimits_getbidis_wua')
+            )) {
+              try {
+                await session.ready
+                const bidistreams = []
+                while (bidistreams.length < 100 - adjustlimit) {
+                  bidistreams.push(
+                    await getReaderValue(session.incomingBidirectionalStreams)
+                  )
+                }
+                await getReaderValue(session.incomingUnidirectionalStreams)
+                await getReaderValue(session.incomingUnidirectionalStreams)
+                for (let i = 0; i < 50 + adjustlimit; i++) {
+                  /* const curstream = */ bidistreams.shift()
+                  // await curstream.writable.close() // canceled by client
+                }
+                while (bidistreams.length < 100 - adjustlimit) {
+                  bidistreams.push(
+                    await getReaderValue(session.incomingBidirectionalStreams)
+                  )
+                }
+                await getReaderValue(session.incomingUnidirectionalStreams)
+                await session.close()
+              } catch (error) {
+                // do not crash server, if a problem occurs...
+              }
+            }
+          },
+          // receive 100+ bidi streams and do not block
+          async () => {
+            for await (const session of getReaderStream(
+              server.sessionStream('/streamlimits_getbidis')
+            )) {
+              try {
+                await session.ready
+                const bidistreams = []
+                while (bidistreams.length < 150) {
+                  bidistreams.push(
+                    await getReaderValue(session.incomingBidirectionalStreams)
+                  )
+                }
+                await session.close()
+              } catch (error) {
+                // do not crash server, if a problem occurs...
+              }
+            }
+          },
+          async () => {
+            for await (const session of getReaderStream(
+              server.sessionStream('/streamlimits_getunidis_wua')
+            )) {
+              try {
+                await session.ready
+                const unidistreams = []
+                while (unidistreams.length < 100 - adjustlimit) {
+                  unidistreams.push(
+                    await getReaderValue(session.incomingUnidirectionalStreams)
+                  )
+                }
+                await getReaderValue(session.incomingBidirectionalStreams)
+                await getReaderValue(session.incomingBidirectionalStreams)
+                for (let i = 0; i < 50 + adjustlimit; i++) {
+                  unidistreams.shift()
+                }
+                while (unidistreams.length < 100 - adjustlimit) {
+                  unidistreams.push(
+                    await getReaderValue(session.incomingUnidirectionalStreams)
+                  )
+                }
+                await getReaderValue(session.incomingBidirectionalStreams)
+                await session.close()
+              } catch (error) {
+                // do not crash server, if a problem occurs...
+              }
+            }
+          },
+          // receive 100+ unidi streams and do not block
+          async () => {
+            for await (const session of getReaderStream(
+              server.sessionStream('/streamlimits_getunidis')
+            )) {
+              try {
+                await session.ready
+                const unidistreams = []
+                while (unidistreams.length < 150) {
+                  unidistreams.push(
+                    await getReaderValue(session.incomingUnidirectionalStreams)
+                  )
+                }
+                await session.close()
+              } catch (error) {
+                // do not crash server, if a problem occurs...
+              }
+            }
+          },
           // cleanly close remote sessions
           async () => {
             for await (const session of getReaderStream(
@@ -281,8 +384,10 @@ if (process.send)
     address: `https://${address.host}:${address.port}`,
     certificate: certificate.fingerprint
   })
-else console.error('No IPC channel')
-/* console.log({
-  address: `https://${address.host}:${address.port}`,
-  certificate: certificate.fingerprint
-}) */
+else {
+  console.error('No IPC channel')
+  console.log({
+    address: `https://${address.host}:${address.port}`,
+    certificate: certificate.fingerprint
+  })
+}

package/test/stream-limits.spec.js

@@ -0,0 +1,247 @@
+/* eslint-env mocha */
+
+import { readCertHash } from './fixtures/read-cert-hash.js'
+import WebTransport from './fixtures/webtransport.js'
+import { expect } from './fixtures/chai.js'
+
+/**
+ * @template T
+ * @typedef {import('../lib/types').Deferred<T>} Deferred<T>
+ */
+describe('streamlimits', function () {
+  this.timeout(6000) // for debugging remove before commit
+  let forceReliable = false
+  let adjustlimit = 1
+  if (process.env.USE_HTTP2 === 'true') {
+    forceReliable = true
+    adjustlimit = 0
+  }
+  const browser = process.env.BROWSER
+  /*  const handshakemess =
+    browser !== 'firefox' ||
+    process.env.USE_POLYFILL === 'true' ||
+    process.env.USE_PONYFILL === 'true'
+      ? 'Opening handshake failed.'
+      : 'WebTransport connection rejected' */
+
+  const dowaitUntilAvailable = browser !== 'chromium' // remove after implementation
+
+  /** @type {import('../lib/dom').WebTransport | undefined} */
+  let client
+
+  const wtOptions = {
+    serverCertificateHashes: [
+      {
+        algorithm: 'sha-256',
+        value: readCertHash(process.env.CERT_HASH)
+      }
+    ],
+    // @ts-ignore
+    forceReliable
+  }
+
+  if (process.env.NO_CERT_HASHES === 'true')
+    // @ts-ignore
+    delete wtOptions.serverCertificateHashes
+
+  // @ts-ignore
+  afterEach(async () => {
+    if (client != null) {
+      client.close()
+      client = undefined
+    }
+  })
+
+  if (dowaitUntilAvailable) {
+    it('should detect stream limit bidi outgoing with waitUntilAvailable = true', async () => {
+      client = new WebTransport(
+        `${process.env.SERVER_URL}/streamlimits_getbidis_wua`,
+        { ...wtOptions }
+      )
+      await client.ready
+      const bidistreams = []
+      let numbidi = 0
+      for (let i = 0; i < 150; i++) {
+        const curstream = client.createBidirectionalStream({
+          waitUntilAvailable: true
+        })
+        bidistreams.push(curstream)
+        curstream
+          .then(() => {
+            numbidi++
+          })
+          .catch(() => {})
+      }
+      await client.createUnidirectionalStream({
+        waitUntilAvailable: true
+      })
+      expect(numbidi).to.equal(100 - adjustlimit)
+      await client.createUnidirectionalStream({
+        waitUntilAvailable: true
+      })
+      for (let i = 0; i < 50 + adjustlimit; i++) {
+        const curstream = await bidistreams.shift()
+        await curstream.readable.cancel()
+        await curstream.writable.close()
+      }
+      await Promise.allSettled(bidistreams)
+      await client.createUnidirectionalStream({
+        waitUntilAvailable: true
+      })
+      expect(numbidi).to.equal(150)
+
+      const result = await client.closed
+      expect(result).to.have.property('closeCode', 0)
+      expect(result).to.have.property('reason', '')
+    })
+  }
+
+  it('should detect stream limit bidi outgoing', async () => {
+    client = new WebTransport(
+      `${process.env.SERVER_URL}/streamlimits_getbidis`,
+      { ...wtOptions }
+    )
+    await client.ready
+    const bidistreams = []
+    let numbidi = 0
+    let numfailed = 0
+    for (let i = 0; i < 150; i++) {
+      const curstream = client.createBidirectionalStream()
+      bidistreams.push(curstream)
+      curstream
+        .then(() => {
+          numbidi++
+        })
+        .catch(() => {
+          numfailed++
+        })
+    }
+    await Promise.allSettled(bidistreams)
+    expect(numbidi).to.equal(100 - adjustlimit)
+    expect(numfailed).to.equal(50 + adjustlimit)
+    numfailed = 0
+    for (let i = 0; i < 50 + adjustlimit; i++) {
+      const curstream = await bidistreams.shift()
+      await curstream.readable.cancel()
+      await curstream.writable.close()
+    }
+    // as close is not a save measure, that the limit is updated
+    // actually no save measure exist, waiting for a typical rtt could be a way
+    // to ensure that the update of maxstreams arrives
+    await new Promise((resolve) => setTimeout(resolve, 200))
+
+    for (let i = 0; i < 50 + adjustlimit; i++) {
+      const curstream = client.createBidirectionalStream()
+      bidistreams.push(curstream)
+      curstream
+        .then(() => {
+          numbidi++
+        })
+        .catch(() => {
+          numfailed++
+        })
+    }
+    await Promise.allSettled(bidistreams)
+    expect(numbidi).to.equal(150)
+    expect(numfailed).to.equal(0)
+
+    const result = await client.closed
+    expect(result).to.have.property('closeCode', 0)
+    expect(result).to.have.property('reason', '')
+  })
+
+  if (dowaitUntilAvailable) {
+    it('should detect stream limit unidi outgoing with waitUntilAvailable = true', async () => {
+      client = new WebTransport(
+        `${process.env.SERVER_URL}/streamlimits_getunidis_wua`,
+        { ...wtOptions }
+      )
+      await client.ready
+      const unidistreams = []
+      let numunidi = 0
+      for (let i = 0; i < 150; i++) {
+        const curstream = client.createUnidirectionalStream({
+          waitUntilAvailable: true
+        })
+        unidistreams.push(curstream)
+        curstream
+          .then(() => {
+            numunidi++
+          })
+          .catch(() => {})
+      }
+      await client.createBidirectionalStream({
+        waitUntilAvailable: true
+      })
+      expect(numunidi).to.equal(100)
+      await client.createBidirectionalStream({
+        waitUntilAvailable: true
+      })
+      for (let i = 0; i < 50 + adjustlimit; i++) {
+        const curstream = await unidistreams.shift()
+        await curstream.close()
+      }
+      await Promise.allSettled(unidistreams)
+      await client.createBidirectionalStream({
+        waitUntilAvailable: true
+      })
+      expect(numunidi).to.equal(150)
+
+      const result = await client.closed
+      expect(result).to.have.property('closeCode', 0)
+      expect(result).to.have.property('reason', '')
+    })
+  }
+
+  it('should detect stream limit unidi outgoing', async () => {
+    client = new WebTransport(
+      `${process.env.SERVER_URL}/streamlimits_getunidis`,
+      { ...wtOptions }
+    )
+    await client.ready
+    const unidistreams = []
+    let numunidi = 0
+    let numfailed = 0
+    for (let i = 0; i < 150; i++) {
+      const curstream = client.createUnidirectionalStream()
+      unidistreams.push(curstream)
+      curstream
+        .then(() => {
+          numunidi++
+        })
+        .catch(() => {
+          numfailed++
+        })
+    }
+    await Promise.allSettled(unidistreams)
+    expect(numunidi).to.equal(100)
+    expect(numfailed).to.equal(50)
+    numfailed = 0
+    for (let i = 0; i < 50 + adjustlimit; i++) {
+      const curstream = await unidistreams.shift()
+      await curstream.close()
+    }
+    // as close is not a save measure, that the limit is updated
+    // actually no save measure exist, waiting for a typical rtt could be a way
+    // to ensure that the update of maxstreams arrives
+    await new Promise((resolve) => setTimeout(resolve, 200))
+    for (let i = 0; i < 50; i++) {
+      const curstream = client.createUnidirectionalStream()
+      unidistreams.push(curstream)
+      curstream
+        .then(() => {
+          numunidi++
+        })
+        .catch(() => {
+          numfailed++
+        })
+    }
+    await Promise.allSettled(unidistreams)
+    expect(numunidi).to.equal(150)
+    expect(numfailed).to.equal(0)
+
+    const result = await client.closed
+    expect(result).to.have.property('closeCode', 0)
+    expect(result).to.have.property('reason', '')
+  })
+})