@fails-components/webtransport 0.2.2 → 0.3.0

package/test/bidirectional-streams.spec.js

@@ -1,136 +1,79 @@
 /* eslint-env mocha */
 
-import { createServer } from './fixtures/server.js'
 import { getReaderValue } from './fixtures/reader-value.js'
-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 { readCertHash } from './fixtures/read-cert-hash.js'
+import WebTransport from './fixtures/webtransport.js'
 import * as ui8 from 'uint8arrays'
+import { KNOWN_BYTES, KNOWN_BYTES_LENGTH } from './fixtures/known-bytes.js'
 
 /**
  * @template T
  * @typedef {import('../lib/types').Deferred<T>} Deferred<T>
  */
 
-const SERVER_PATH = '/bidirectional-streams'
-
 describe('bidirectional streams', function () {
-  /** @type {import('../lib/server').Http3Server} */
-  let server
-  /** @type {import('./fixtures/certificate.js').Certificate} */
-  let certificate
+  // FIXME: sometimes there are seemingly arbitrary 5s delays in
+  // communicating with the server under node.js
+  this.timeout(30000)
+
   /** @type {import('../lib/dom').WebTransport | undefined} */
   let client
-  /** @type {string} */
-  let url
-
-  this.timeout(30000) // this can vary depending on the setup and is not an error
-  // but it smells like a work around regarding a deeper problem
-
-  beforeEach(async () => {
-    this.timeout(2000)
-    ;({ server, certificate } = await createServer())
-    server.startServer()
-    await server.ready
-
-    const address = server.address()
-
-    if (address == null || address.port == null) {
-      throw new Error('No address')
-    }
-
-    url = `https://${address.host}:${address.port}`
-  })
 
   // @ts-ignore
   afterEach(async () => {
     if (client != null) {
       client.close()
-    }
-
-    if (server != null) {
-      server.stopServer()
-      await server.closed
+      client = undefined
     }
   })
 
   it('sends and receives data over an outgoing bidirectional stream', async () => {
-    this.timeout(200)
-    // 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
-      )
-      // redirect input to output
-      await bidiStream.readable.pipeTo(bidiStream.writable)
-    })
-
     // client context - connects to the server, opens a bidi stream, sends some data and reads the response
-    client = new WebTransport(`${url}${SERVER_PATH}`, {
-      serverCertificateHashes: [
-        {
-          algorithm: 'sha-256',
-          value: certificate.hash
-        }
-      ]
-    })
+    client = new WebTransport(
+      `${process.env.SERVER_URL}/bidirectional_client_initiated_echo`,
+      {
+        serverCertificateHashes: [
+          {
+            algorithm: 'sha-256',
+            value: readCertHash(process.env.CERT_HASH)
+          }
+        ]
+      }
+    )
     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.createBidirectionalStream()
-    await writeStream(stream.writable, input)
+    await writeStream(stream.writable, KNOWN_BYTES)
 
-    const output = await readStream(stream.readable, ui8.concat(input).length)
-    expect(ui8.concat(output)).to.deep.equal(
-      ui8.concat(input),
+    const output = await readStream(stream.readable, KNOWN_BYTES_LENGTH)
+    expect(ui8.concat(KNOWN_BYTES)).to.deep.equal(
+      ui8.concat(output),
       'Did not receive the same bytes we sent'
     )
   })
 
   it('sends and receives data over an incoming bidirectional stream', 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, 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, 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
-    client = new WebTransport(`${url}${SERVER_PATH}`, {
-      serverCertificateHashes: [
-        {
-          algorithm: 'sha-256',
-          value: certificate.hash
-        }
-      ]
-    })
+    client = new WebTransport(
+      `${process.env.SERVER_URL}/bidirectional_server_initiated_echo`,
+      {
+        serverCertificateHashes: [
+          {
+            algorithm: 'sha-256',
+            value: readCertHash(process.env.CERT_HASH)
+          }
+        ]
+      }
+    )
     await client.ready
 
     const bidiStream = await getReaderValue(client.incomingBidirectionalStreams)
+
     // redirect input to output
     try {
       await bidiStream.readable.pipeTo(bidiStream.writable)
@@ -138,10 +81,11 @@ describe('bidirectional streams', function () {
       console.log('Pipe to error (ignore)', error) // Actually all you can get is, that the fin is catched
     }
 
-    const received = await serverData.promise
-    expect(ui8.concat(received)).to.deep.equal(
-      ui8.concat(input),
-      'Did not receive the same bytes we sent'
-    )
+    // the remote will close the session
+    const result = await client.closed
+
+    // should receive the default close info
+    expect(result).to.have.property('reason', '')
+    expect(result).to.have.property('closeCode', 0)
   })
 })

package/test/datagrams.spec.js

@@ -1,12 +1,9 @@
 /* eslint-env mocha */
 
-import { createServer } from './fixtures/server.js'
-import { getReaderValue } from './fixtures/reader-value.js'
-import { WebTransport } from '../lib/index.js'
+import WebTransport from './fixtures/webtransport.js'
 import { expect } from './fixtures/chai.js'
 import { readStream } from './fixtures/read-stream.js'
-import { writeStream } from './fixtures/write-stream.js'
-import * as ui8 from 'uint8arrays'
+import { readCertHash } from './fixtures/read-cert-hash.js'
 import { pTimeout } from './fixtures/p-timeout.js'
 
 /**
@@ -14,119 +11,75 @@ import { pTimeout } from './fixtures/p-timeout.js'
  * @typedef {import('../lib/types').Deferred<T>} Deferred<T>
  */
 
-const SERVER_PATH = '/datagrams'
-
 describe('datagrams', function () {
-  /** @type {import('../lib/server').Http3Server} */
-  let server
-  /** @type {import('./fixtures/certificate.js').Certificate} */
-  let certificate
+  // FIXME: sometimes there are seemingly arbitrary 5s delays in
+  // communicating with the server under node.js
+  this.timeout(30000)
+
   /** @type {import('../lib/dom').WebTransport | undefined} */
   let client
-  /** @type {string} */
-  let url
-
-  beforeEach(async () => {
-    ;({ server, certificate } = await createServer())
-    server.startServer()
-    await server.ready
-
-    const address = server.address()
-
-    if (address == null || address.port == null) {
-      throw new Error('No address')
-    }
-
-    url = `https://${address.host}:${address.port}`
-  })
 
   // @ts-ignore
   afterEach(async () => {
     if (client != null) {
       client.close()
-    }
-
-    if (server != null) {
-      server.stopServer()
-      await server.closed
+      client = undefined
     }
   })
-
   it('client sends datagrams to the server', async () => {
-    this.timeout(200)
-    // server context - waits for the client to connect and pipes their datagrams back to them
-    Promise.resolve().then(async () => {
-      const session = await getReaderValue(server.sessionStream(SERVER_PATH))
+    // client context - connects to the server, sends some datagrams and reads the response
+    client = new WebTransport(
+      `${process.env.SERVER_URL}/datagrams_client_send`,
+      {
+        serverCertificateHashes: [
+          {
+            algorithm: 'sha-256',
+            value: readCertHash(process.env.CERT_HASH)
+          }
+        ]
+      }
+    )
+    await client.ready
 
-      // redirect input to output
-      await session.datagrams.readable.pipeTo(session.datagrams.writable)
-    })
+    const writer = client.datagrams.writable.getWriter()
+    let closed = false
 
-    // client context - connects to the server, sends some datagrams and reads the response
-    client = new WebTransport(`${url}${SERVER_PATH}`, {
-      serverCertificateHashes: [
-        {
-          algorithm: 'sha-256',
-          value: certificate.hash
+    // write datagrams until the server receives one and closes the connection
+    // eslint-disable-next-line promise/catch-or-return
+    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, 100))
+        } catch {
+          // the session can be closed while we are writing
         }
-      ]
+      }
     })
-    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])
-    ]
 
-    await writeStream(client.datagrams.writable, input)
+    const result = await client.closed
+    closed = true
 
-    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'
-    )
+    // should receive the default close info
+    expect(result).to.have.property('reason', '')
+    expect(result).to.have.property('closeCode', 0)
   })
 
   it('receives datagrams from the server', async () => {
-    this.timeout(200)
-
-    // 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))
-
-      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
-      await session.closed
-      closed = true
-    })
-
     // client context - pipes the server's datagrams back to them
-    client = new WebTransport(`${url}${SERVER_PATH}`, {
-      serverCertificateHashes: [
-        {
-          algorithm: 'sha-256',
-          value: certificate.hash
-        }
-      ]
-    })
+    client = new WebTransport(
+      `${process.env.SERVER_URL}/datagrams_server_send`,
+      {
+        serverCertificateHashes: [
+          {
+            algorithm: 'sha-256',
+            value: readCertHash(process.env.CERT_HASH)
+          }
+        ]
+      }
+    )
     await client.ready
 
     // datagram transport is unreliable, at least one message should make it through
@@ -136,8 +89,6 @@ describe('datagrams', function () {
       readStream(client.datagrams.readable, expected),
       1000
     )
-    await client.close()
-    client = undefined
     expect(received).to.have.lengthOf(expected)
   })
 })

package/test/fixtures/chai.js

@@ -1,6 +1,8 @@
 import chai from 'chai'
 import dirtyChai from 'dirty-chai'
+import chaiAsPromised from 'chai-as-promised'
 
 chai.use(dirtyChai)
+chai.use(chaiAsPromised)
 
 export const expect = chai.expect

package/test/fixtures/known-bytes.js

@@ -0,0 +1,15 @@
+/**
+ * Bytes send by tests
+ */
+export const KNOWN_BYTES = [
+  Uint8Array.from([0, 1, 2, 3, 4]),
+  Uint8Array.from([5, 6, 7, 8, 9]),
+  Uint8Array.from([10, 11, 12, 13, 14]),
+  Uint8Array.from([15, 16, 17, 18, 19]),
+  Uint8Array.from([20, 21, 22, 23, 24])
+]
+
+export const KNOWN_BYTES_LENGTH = KNOWN_BYTES.reduce(
+  (accumulator, currentValue) => accumulator + currentValue.length,
+  0
+)

package/test/fixtures/read-cert-hash.js

@@ -0,0 +1,7 @@
+/**
+ * @param {string} [certHash]
+ * @returns {Uint8Array}
+ */
+export function readCertHash(certHash) {
+  return Uint8Array.from(`${certHash}`.split(':').map((i) => parseInt(i, 16)))
+}

package/test/fixtures/read-stream.js

@@ -1,3 +1,8 @@
+/**
+ * @template T
+ * @typedef {import('node:stream/web').ReadableStream<T>} ReadableStream<T>
+ */
+
 /**
  * Read a stream contents to the end and return it
  *

package/test/fixtures/reader-value.js

@@ -1,3 +1,8 @@
+/**
+ * @template T
+ * @typedef {import('node:stream/web').ReadableStream<T>} ReadableStream<T>
+ */
+
 /**
  * @template T
  * @param {ReadableStream<T>} readableStream
@@ -22,3 +27,30 @@ export async function getReaderValue(readableStream) {
     reader.releaseLock()
   }
 }
+
+/**
+ * @template T
+ * @param {ReadableStream<T>} readableStream
+ * @returns {AsyncGenerator<T>}
+ */
+export async function* getReaderStream(readableStream) {
+  const reader = readableStream.getReader()
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read()
+
+      if (done) {
+        return
+      }
+
+      if (!value) {
+        throw new Error('Stream value was undefined')
+      }
+
+      yield value
+    }
+  } finally {
+    reader.releaseLock()
+  }
+}