@fails-components/webtransport 0.2.2 → 0.3.0

package/test/fixtures/server.js

@@ -1,5 +1,11 @@
 import { generateWebTransportCertificate } from './certificate.js'
 import { Http3Server } from '../../lib/index.js'
+import { pTimeout } from './p-timeout.js'
+import { getReaderStream, getReaderValue } from './reader-value.js'
+import { writeStream } from './write-stream.js'
+import { readStream } from './read-stream.js'
+import * as ui8 from 'uint8arrays'
+import { KNOWN_BYTES, KNOWN_BYTES_LENGTH } from './known-bytes.js'
 
 export async function createServer() {
   const attrs = [
@@ -19,6 +25,8 @@ export async function createServer() {
   }
 
   const server = new Http3Server({
+    /*   port: 8080,
+    host: '0.0.0.0', */
     port: 0,
     host: '127.0.0.1',
     secret: 'mysecret',
@@ -26,33 +34,241 @@ export async function createServer() {
     privKey: certificate.private
   })
 
+  server.ready
+    .then(async () => {
+      // set up listeners for the different server paths used by the tests
+
+      await Promise.all(
+        [
+          // echo server, initiated by remote
+          async () => {
+            for await (const session of getReaderStream(
+              server.sessionStream('/bidirectional_client_initiated_echo')
+            )) {
+              try {
+                const bidiStream = await getReaderValue(
+                  session.incomingBidirectionalStreams
+                )
+
+                // redirect input to output
+                await bidiStream.readable.pipeTo(bidiStream.writable)
+              } catch {
+                // in some tests the client closes the stream
+              }
+            }
+          },
+
+          // echo server, initiated by local
+          async () => {
+            for await (const session of getReaderStream(
+              server.sessionStream('/bidirectional_server_initiated_echo')
+            )) {
+              try {
+                const stream = await session.createBidirectionalStream()
+
+                await writeStream(stream.writable, KNOWN_BYTES)
+
+                const received = await readStream(
+                  stream.readable,
+                  KNOWN_BYTES_LENGTH
+                )
+                // await stream.readable.cancel() // cancel so that the client can progress
+
+                // if we did not get the data we sent, close the session with a reason
+                if (
+                  !ui8.equals(ui8.concat(KNOWN_BYTES), ui8.concat(received))
+                ) {
+                  session.close({
+                    closeCode: 500,
+                    reason: 'data did not match'
+                  })
+                } else {
+                  session.close()
+                }
+              } catch {
+                // in some tests the client closes the stream
+              }
+            }
+          },
+
+          // echo datagrams, initiated by remote
+          async () => {
+            for await (const session of getReaderStream(
+              server.sessionStream('/datagrams_client_send')
+            )) {
+              // datagram transport is unreliable, at least one message should make it through
+              const expected = 1
+
+              try {
+                const received = await pTimeout(
+                  readStream(session.datagrams.readable, expected),
+                  1000
+                )
+
+                // if we did not get the data we sent, close the session with a reason
+                if (received.length !== expected) {
+                  throw new Error('Did not receive enough bytes')
+                }
+
+                session.close()
+              } catch (/** @type {any} */ err) {
+                session.close({
+                  closeCode: 500,
+                  reason: err.message
+                })
+              }
+            }
+          },
+
+          // echo datagrams, initiated by local
+          async () => {
+            for await (const session of getReaderStream(
+              server.sessionStream('/datagrams_server_send')
+            )) {
+              const writer = session.datagrams.writable.getWriter()
+              let closed = false
+
+              // write datagrams until the client 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, 1)) // do not flood everything
+                  } catch {
+                    // the session can be closed while we are writing
+                  }
+                }
+              })
+
+              await session.closed
+              closed = true
+            }
+          },
+
+          // cleanly close remote sessions
+          async () => {
+            for await (const session of getReaderStream(
+              server.sessionStream('/session_close')
+            )) {
+              session.close()
+            }
+          },
+
+          // cleanly close remote sessions
+          async () => {
+            for await (const session of getReaderStream(
+              server.sessionStream('/session_close_with_reason')
+            )) {
+              session.close({
+                closeCode: 7,
+                reason: 'this is the reason'
+              })
+            }
+          },
+
+          // send data over unidirectional stream, initiated by remote
+          async () => {
+            for await (const session of getReaderStream(
+              server.sessionStream('/unidirectional_client_send')
+            )) {
+              try {
+                const stream = await getReaderValue(
+                  session.incomingUnidirectionalStreams
+                )
+                const received = await readStream(stream, KNOWN_BYTES_LENGTH)
+                // await stream.cancel() // cancel so that the client can progress
+                // if we did not get the data we sent, close the session with a reason
+                if (
+                  !ui8.equals(ui8.concat(KNOWN_BYTES), ui8.concat(received))
+                ) {
+                  session.close({
+                    closeCode: 500,
+                    reason: 'data did not match'
+                  })
+                } else {
+                  session.close()
+                }
+              } catch (error) {
+                // in some tests the client closes the stream
+              }
+            }
+          },
+
+          // send data over unidirectional stream, initiated by local
+          async () => {
+            for await (const session of getReaderStream(
+              server.sessionStream('/unidirectional_server_send')
+            )) {
+              const stream = await session.createUnidirectionalStream()
+
+              await writeStream(stream, KNOWN_BYTES)
+            }
+          },
+
+          // delays reading from stream after client writes
+          async () => {
+            for await (const session of getReaderStream(
+              server.sessionStream('/unidirectional_server_delay_before_read')
+            )) {
+              const stream = await getReaderValue(
+                session.incomingUnidirectionalStreams
+              )
+
+              // wait before we read from the stream, should trigger backpressure
+              // on the client
+              await new Promise((resolve) => setTimeout(resolve, 1000))
+
+              const received = await readStream(stream, KNOWN_BYTES_LENGTH)
+              // await stream.cancel() // cancel so that the client can progress
+
+              // if we did not get expected data, close the session with a reason
+              if (!ui8.equals(ui8.concat(KNOWN_BYTES), ui8.concat(received))) {
+                console.log('ERROR', KNOWN_BYTES, received)
+                session.close({
+                  closeCode: 500,
+                  reason: 'data did not match'
+                })
+              } else {
+                await new Promise((resolve) => setTimeout(resolve, 2000)) // time out is needed, since it can be received before the read is complete
+                // and we want the client to close the session after it has processeed the read
+                session.close()
+              }
+            }
+          }
+        ].map((fn) => fn())
+      )
+    })
+    .catch((/** @type {any} */ err) => {
+      console.error('server crashed', err)
+    })
+
   return {
     server,
     certificate
   }
 }
 
-/**
- * @param {import('../../lib/server.js').Http3Server} server
- * @param {string} path
- */
-export async function getServerSession(server, path) {
-  const sessionStream = await server.sessionStream(path)
-  const sessionReader = sessionStream.getReader()
-
-  try {
-    const { done, value } = await sessionReader.read()
-
-    if (done) {
-      throw new Error('Server is gone')
-    }
+const { server, certificate } = await createServer()
+server.startServer()
+await server.ready
 
-    if (!value) {
-      throw new Error('Session was undefined')
-    }
+const address = server.address()
 
-    return value
-  } finally {
-    sessionReader.releaseLock()
-  }
+if (address == null) {
+  throw new Error('Could not determine server address')
 }
+
+// tell the calling process how to contact us
+if (process.send)
+  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
+}) */

package/test/fixtures/webtransport.browser.js

@@ -0,0 +1,2 @@
+// @ts-expect-error not TypeScript's dom.d.ts yet
+export default WebTransport // eslint-disable-line no-undef

package/test/fixtures/webtransport.js

@@ -0,0 +1,3 @@
+import { WebTransport } from '../../lib/index.js'
+
+export default WebTransport

package/test/fixtures/write-stream.js

@@ -10,8 +10,15 @@ export async function writeStream(writable, input) {
   const writer = writable.getWriter()
 
   for (const buf of input) {
+    await writer.ready
     await writer.write(buf)
   }
 
-  await writer.close()
+  await writer.ready
+  await writer.releaseLock()
+  try {
+    await writable.close()
+  } catch (error) {
+    console.log('Did we get a STOP_SENDING? ignore', error)
+  }
 }

package/test/index.js

@@ -0,0 +1,87 @@
+import { execa } from 'execa'
+
+/**
+ * Run server as separate process so we can kill it without
+ * getting stuck waiting for the custom event loop to end.
+ */
+async function startServer() {
+  return new Promise((resolve, reject) => {
+    let foundAddress = false
+
+    const server = execa('node', ['./test/fixtures/server.js'], {
+      stdio: ['inherit', 'inherit', 'inherit', 'ipc']
+    })
+    server.on('message', (data) => {
+      if (!foundAddress) {
+        foundAddress = true
+
+        resolve(data)
+      }
+    })
+  })
+}
+
+/**
+ * @param {string} certificate
+ * @param {string} serverAddress
+ */
+async function runTests(certificate, serverAddress) {
+  const env = process.argv[2]
+  /** @type {string} */
+  let command = ''
+  /** @type {string[]} */
+  let args = []
+
+  if (env === 'node') {
+    command = 'mocha'
+    args = [
+      process.env.CI ? '--no-colors' : '--colors',
+      './test/*.spec.js',
+      './test/*.node.js',
+      ...process.argv.slice(3)
+    ]
+    const tests = execa(command, args, {
+      env: {
+        DEBUG_COLORS: process.env.CI ? '' : 'true',
+        CERT_HASH: certificate,
+        SERVER_URL: serverAddress
+      },
+      stdio: ['inherit', 'inherit', 'inherit']
+    })
+
+    await tests
+  } else if (env === 'chromium') {
+    command = 'playwright-test'
+    args = ['./test/*.spec.js', ...process.argv.slice(3)]
+    const tests = execa(command, args, {
+      env: {
+        DEBUG_COLORS: process.env.CI ? '' : 'true',
+        CERT_HASH: certificate,
+        SERVER_URL: serverAddress
+      },
+      stdio: ['inherit', 'inherit', 'inherit']
+    })
+
+    await tests
+  }
+}
+
+let success = true
+
+try {
+  const { address, certificate } = await startServer()
+
+  await runTests(certificate, address)
+} catch (/** @type {any} */ err) {
+  if (err.command == null) {
+    // was not an execa error
+    throw err
+  }
+
+  if (err.failed || err.timedOut || err.isCancelled || err.isKilled) {
+    success = false
+  }
+} finally {
+  // this will cause the server process to exit too as it is a child of this process
+  process.exit(success ? 0 : 1)
+}

package/test/session.spec.js

@@ -0,0 +1,159 @@
+/* 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('session', function () {
+  // 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
+
+  // @ts-ignore
+  afterEach(async () => {
+    if (client != null) {
+      client.close()
+      client = undefined
+    }
+  })
+
+  it('should detect session closure', async () => {
+    client = new WebTransport(`${process.env.SERVER_URL}/session_close`, {
+      serverCertificateHashes: [
+        {
+          algorithm: 'sha-256',
+          value: readCertHash(process.env.CERT_HASH)
+        }
+      ]
+    })
+    await client.ready
+
+    const result = await client.closed
+    expect(result).to.have.property('closeCode', 0)
+    expect(result).to.have.property('reason', '')
+  })
+
+  it('should detect session closure with close info', async () => {
+    // client context - connects to the server, sends some datagrams and reads the response
+    client = new WebTransport(
+      `${process.env.SERVER_URL}/session_close_with_reason`,
+      {
+        serverCertificateHashes: [
+          {
+            algorithm: 'sha-256',
+            value: readCertHash(process.env.CERT_HASH)
+          }
+        ]
+      }
+    )
+    await client.ready
+
+    const result = await client.closed
+    expect(result).to.have.property('closeCode', 7)
+    expect(result).to.have.property('reason', 'this is the reason')
+  })
+
+  it('should error when connecting to a server that does not exist', async () => {
+    client = new WebTransport(`https://127.0.0.1:39821`, {
+      serverCertificateHashes: [
+        {
+          algorithm: 'sha-256',
+          value: readCertHash(process.env.CERT_HASH)
+        }
+      ],
+      quicConnectTimeout: 100,
+      webTransportConnectTimeout: 100
+    })
+
+    const [closedResult, readyResult] = await Promise.all([
+      client.closed.catch((err) => err),
+      client.ready.catch((err) => err)
+    ])
+
+    expect(closedResult)
+      .to.be.a('WebTransportError')
+      .with.property('message', 'Opening handshake failed.')
+    expect(readyResult)
+      .to.be.a('WebTransportError')
+      .with.property('message', 'Opening handshake failed.')
+  })
+
+  it('should error when connecting to a path that does not exist', async () => {
+    client = new WebTransport(`${process.env.SERVER_URL}/non_existant`, {
+      serverCertificateHashes: [
+        {
+          algorithm: 'sha-256',
+          value: readCertHash(process.env.CERT_HASH)
+        }
+      ]
+    })
+
+    const [closedResult, readyResult] = await Promise.all([
+      client.closed.catch((err) => err),
+      client.ready.catch((err) => err)
+    ])
+
+    expect(closedResult)
+      .to.be.a('WebTransportError')
+      .with.property('message', 'Opening handshake failed.')
+    expect(readyResult)
+      .to.be.a('WebTransportError')
+      .with.property('message', 'Opening handshake failed.')
+  })
+
+  it('should error when connecting with a bad certificate', async () => {
+    client = new WebTransport(`${process.env.SERVER_URL}/session_close`, {
+      serverCertificateHashes: [
+        {
+          algorithm: 'sha-256',
+          value: readCertHash(process.env.CERT_HASH + ':DE:AD:BE:EF')
+        }
+      ]
+    })
+
+    const [closedResult, readyResult] = await Promise.all([
+      client.closed.catch((err) => err),
+      client.ready.catch((err) => err)
+    ])
+
+    expect(closedResult)
+      .to.be.a('WebTransportError')
+      .with.property('message', 'Opening handshake failed.')
+    expect(readyResult)
+      .to.be.a('WebTransportError')
+      .with.property('message', 'Opening handshake failed.')
+  })
+
+  it('should error when connecting with the wrong certificate', async () => {
+    client = new WebTransport(`${process.env.SERVER_URL}/session_close`, {
+      serverCertificateHashes: [
+        {
+          algorithm: 'sha-256',
+          value: readCertHash(
+            'DE:AD:BE:EF:' + process.env.CERT_HASH?.substring(12)
+          )
+        }
+      ]
+    })
+
+    const [closedResult, readyResult] = await Promise.all([
+      client.closed.catch((err) => err),
+      client.ready.catch((err) => err)
+    ])
+
+    expect(closedResult)
+      .to.be.a('WebTransportError')
+      .with.property('message', 'Opening handshake failed.')
+    expect(readyResult)
+      .to.be.a('WebTransportError')
+      .with.property('message', 'Opening handshake failed.')
+  })
+})