@fails-components/webtransport 0.1.7 → 0.2.0

package/test/bidirectional-streams.spec.js

@@ -7,6 +7,7 @@ import { expect } from './fixtures/chai.js'
 import { readStream } from './fixtures/read-stream.js'
 import { writeStream } from './fixtures/write-stream.js'
 import { defer } from '../lib/utils.js'
+import * as ui8 from 'uint8arrays'
 
 /**
  * @template T
@@ -60,6 +61,7 @@ describe('bidirectional streams', function () {
     // server context - waits for the client to open a bidi stream and pipes it back to them
     Promise.resolve().then(async () => {
       const session = await getReaderValue(server.sessionStream(SERVER_PATH))
+      if (!session) throw new Error('Got no session')
       const bidiStream = await getReaderValue(
         session.incomingBidirectionalStreams
       )
@@ -87,9 +89,9 @@ describe('bidirectional streams', function () {
     const stream = await client.createBidirectionalStream()
     await writeStream(stream.writable, input)
 
-    const output = await readStream(stream.readable)
-    expect(output).to.deep.equal(
-      input,
+    const output = await readStream(stream.readable, ui8.concat(input).length)
+    expect(ui8.concat(output)).to.deep.equal(
+      ui8.concat(input),
       'Did not receive the same bytes we sent'
     )
   })
@@ -107,12 +109,14 @@ describe('bidirectional streams', function () {
     // server context - waits for the client to connect, opens a bidi stream, sends some data and reads the response
     Promise.resolve().then(async () => {
       const session = await getReaderValue(server.sessionStream(SERVER_PATH))
+      if (!session) throw new Error('Got no session')
       const stream = await session.createBidirectionalStream()
 
       await writeStream(stream.writable, input)
 
-      const output = await readStream(stream.readable)
+      const output = await readStream(stream.readable, ui8.concat(input).length)
       serverData.resolve(output)
+      await stream.readable.cancel() // cancel so that the client can progress
     })
 
     // client context - waits for the server to open a bidi stream then pipes it back to them
@@ -128,11 +132,15 @@ describe('bidirectional streams', function () {
 
     const bidiStream = await getReaderValue(client.incomingBidirectionalStreams)
     // redirect input to output
-    await bidiStream.readable.pipeTo(bidiStream.writable)
+    try {
+      await bidiStream.readable.pipeTo(bidiStream.writable)
+    } catch (error) {
+      console.log('Pipe to error (ignore)', error) // Actually all you can get is, that the fin is catched
+    }
 
     const received = await serverData.promise
-    expect(received).to.deep.equal(
-      input,
+    expect(ui8.concat(received)).to.deep.equal(
+      ui8.concat(input),
       'Did not receive the same bytes we sent'
     )
   })

package/test/datagrams.spec.js

@@ -6,7 +6,8 @@ import { WebTransport } from '../lib/index.js'
 import { expect } from './fixtures/chai.js'
 import { readStream } from './fixtures/read-stream.js'
 import { writeStream } from './fixtures/write-stream.js'
-import { defer } from '../lib/utils.js'
+import * as ui8 from 'uint8arrays'
+import { pTimeout } from './fixtures/p-timeout.js'
 
 /**
  * @template T
@@ -80,7 +81,10 @@ describe('datagrams', function () {
 
     await writeStream(client.datagrams.writable, input)
 
-    const output = await readStream(client.datagrams.readable, input.length)
+    const output = await readStream(
+      client.datagrams.readable,
+      ui8.concat(input).length
+    )
     expect(output).to.deep.equal(
       input,
       'Did not receive the same bytes we sent'
@@ -89,25 +93,29 @@ describe('datagrams', function () {
 
   it('receives datagrams from the server', async () => {
     this.timeout(200)
-    /** @type {Deferred<Uint8Array[]>} */
-    const serverData = defer()
-    const input = [
-      Uint8Array.from([0, 1, 2, 3, 4]),
-      Uint8Array.from([5, 6, 7, 8, 9]),
-      Uint8Array.from([10, 11, 12, 13, 14])
-    ]
 
     // server context - waits for the client to connect, sends some datagrams and reads the response
     Promise.resolve().then(async () => {
       const session = await getReaderValue(server.sessionStream(SERVER_PATH))
 
-      await writeStream(session.datagrams.writable, input)
-
-      const output = await readStream(session.datagrams.readable, input.length)
+      let closed = false
+      const writer = session.datagrams.writable.getWriter()
+      Promise.resolve().then(async () => {
+        // eslint-disable-next-line no-unmodified-loop-condition
+        while (!closed) {
+          try {
+            await writer.ready
+            await writer.write(Uint8Array.from([0, 1, 2, 3, 4]))
+            await new Promise((resolve) => setTimeout(resolve, 1)) // do not flood everything
+          } catch {
+            // the session can be closed while we are writing
+          }
+        }
+      })
 
       // have to close the session to end the client's datagram stream
-      session.close()
-      serverData.resolve(output)
+      await session.closed
+      closed = true
     })
 
     // client context - pipes the server's datagrams back to them
@@ -121,13 +129,15 @@ describe('datagrams', function () {
     })
     await client.ready
 
-    // redirect input to output
-    await client.datagrams.readable.pipeTo(client.datagrams.writable)
+    // datagram transport is unreliable, at least one message should make it through
+    const expected = 1
 
-    const received = await serverData.promise
-    expect(received).to.deep.equal(
-      input,
-      'Did not receive the same bytes we sent'
+    const received = await pTimeout(
+      readStream(client.datagrams.readable, expected),
+      1000
     )
+    await client.close()
+    client = undefined
+    expect(received).to.have.lengthOf(expected)
   })
 })

package/test/fixtures/p-timeout.js

@@ -0,0 +1,33 @@
+class TimeoutError extends Error {
+  /**
+   * @param {string} message
+   */
+  constructor(message) {
+    super(message)
+
+    this.name = this[Symbol.toStringTag] = 'TimeoutError'
+  }
+}
+
+/**
+ * @template T
+ * @param {Promise<T>} promise
+ * @param {number} timeout
+ * @returns {Promise<T>}
+ */
+export async function pTimeout(promise, timeout) {
+  let ref
+
+  const value = await Promise.race([
+    promise,
+    new Promise((resolve, reject) => {
+      ref = setTimeout(() => {
+        reject(new TimeoutError('timeout'))
+      }, timeout)
+    })
+  ])
+
+  clearTimeout(ref)
+
+  return value
+}

package/test/fixtures/read-stream.js

@@ -12,6 +12,7 @@ export async function readStream(readable, expected) {
   try {
     /** @type {T[]} */
     const output = []
+    let outputlength = 0
 
     while (true) {
       const { done, value } = await reader.read()
@@ -21,10 +22,12 @@ export async function readStream(readable, expected) {
       }
 
       if (value != null) {
+        // @ts-ignore
+        outputlength += value.length
         output.push(value)
       }
 
-      if (expected != null && output.length === expected) {
+      if (expected != null && outputlength >= expected) {
         break
       }
     }

package/test/unidirectional-streams.spec.js

@@ -7,6 +7,7 @@ import { expect } from 'chai'
 import { readStream } from './fixtures/read-stream.js'
 import { writeStream } from './fixtures/write-stream.js'
 import { defer } from '../lib/utils.js'
+import * as ui8 from 'uint8arrays'
 
 /**
  * @template T
@@ -56,13 +57,21 @@ describe('unidirectional streams', function () {
     /** @type {Deferred<Uint8Array[]>} */
     const serverData = defer()
 
+    const input = [
+      Uint8Array.from([0, 1, 2, 3, 4]),
+      Uint8Array.from([5, 6, 7, 8, 9]),
+      Uint8Array.from([10, 11, 12, 13, 14])
+    ]
+
     // server context - waits for the client to open a bidi stream and pipes it back to them
     Promise.resolve().then(async () => {
       const session = await getReaderValue(server.sessionStream(SERVER_PATH))
+      if (!session) throw new Error('no session')
       const stream = await getReaderValue(session.incomingUnidirectionalStreams)
 
-      const output = await readStream(stream)
+      const output = await readStream(stream, ui8.concat(input).length)
       serverData.resolve(output)
+      await stream.cancel() // cancel so that the client can progress
     })
 
     // client context - connects to the server, opens a bidi stream, sends some data and reads the response
@@ -76,18 +85,12 @@ describe('unidirectional streams', function () {
     })
     await client.ready
 
-    const input = [
-      Uint8Array.from([0, 1, 2, 3, 4]),
-      Uint8Array.from([5, 6, 7, 8, 9]),
-      Uint8Array.from([10, 11, 12, 13, 14])
-    ]
-
     const stream = await client.createUnidirectionalStream()
     await writeStream(stream, input)
 
     const received = await serverData.promise
-    expect(received).to.deep.equal(
-      input,
+    expect(ui8.concat(received)).to.deep.equal(
+      ui8.concat(input),
       'Server did not receive the same bytes we sent'
     )
   })
@@ -103,6 +106,7 @@ describe('unidirectional streams', function () {
     // server context - waits for the client to connect, opens a bidi stream, sends some data and reads the response
     Promise.resolve().then(async () => {
       const session = await getReaderValue(server.sessionStream(SERVER_PATH))
+      if (!session) throw new Error('no session')
       const stream = await session.createUnidirectionalStream()
 
       await writeStream(stream, input)
@@ -120,9 +124,9 @@ describe('unidirectional streams', function () {
     await client.ready
 
     const stream = await getReaderValue(client.incomingUnidirectionalStreams)
-    const received = await readStream(stream)
-    expect(received).to.deep.equal(
-      input,
+    const received = await readStream(stream, ui8.concat(input).length)
+    expect(ui8.concat(received)).to.deep.equal(
+      ui8.concat(input),
       'Did not receive the same bytes we sent'
     )
   })
@@ -135,6 +139,7 @@ describe('unidirectional streams', function () {
 
     Promise.resolve().then(async () => {
       const session = await getReaderValue(server.sessionStream(SERVER_PATH))
+      if (!session) throw new Error('Got no session')
       const stream = await getReaderValue(session.incomingUnidirectionalStreams)
 
       serverStream.resolve(stream)
@@ -172,9 +177,12 @@ describe('unidirectional streams', function () {
 
     await new Promise((resolve) => setTimeout(resolve, 1000))
 
-    const received = await readStream(await serverStream.promise)
-    expect(received).to.deep.equal(
-      input,
+    const received = await readStream(
+      await serverStream.promise,
+      ui8.concat(input).length
+    )
+    expect(ui8.concat(received)).to.deep.equal(
+      ui8.concat(input),
       'Did not receive the same bytes we sent'
     )
   })