@fails-components/webtransport 0.0.9 → 0.1.0-macarmbuild.6

package/test/event-loop.spec.js

@@ -0,0 +1,24 @@
+/* eslint-env mocha */
+
+import { expect } from './fixtures/chai.js'
+import { Http3EventLoop } from '../lib/event-loop.js'
+
+describe.skip('event-loop', () => {
+  beforeEach(() => {
+    if (Http3EventLoop.globalLoop != null) {
+      // shut down loop, otherwise we have to wait for
+      // it to time out which takes a long time.
+      Http3EventLoop.globalLoop.shutdownEventLoop()
+    }
+  })
+
+  it('should start and stop the event loop', () => {
+    expect(Http3EventLoop.globalLoop).to.be.null()
+
+    Http3EventLoop.createGlobalEventLoop()
+    expect(Http3EventLoop.globalLoop).to.not.be.null()
+
+    Http3EventLoop.globalLoop?.shutdownEventLoop()
+    expect(Http3EventLoop.globalLoop).to.be.null()
+  })
+})

package/test/{certificate.js → fixtures/certificate.js}

@@ -53,16 +53,16 @@ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
 
+// @ts-expect-error node-forge has no types and @types/node-forge do not include oids
 import forge from 'node-forge'
-import { webcrypto as crypto } from 'crypto'
-import { X509Certificate } from 'crypto'
+import { webcrypto as crypto, X509Certificate } from 'crypto'
 
 const { pki, asn1, oids } = forge
 // taken from node-forge
 /**
  * Converts an X.509 subject or issuer to an ASN.1 RDNSequence.
  *
- * @param obj the subject or issuer (distinguished name).
+ * @param {any} obj the subject or issuer (distinguished name).
  *
  * @return the ASN.1 RDNSequence.
  */
@@ -110,19 +110,19 @@ function _dnToAsn1(obj) {
   return rval
 }
 
+const jan_1_1950 = new Date('1950-01-01T00:00:00Z') // eslint-disable-line camelcase
+const jan_1_2050 = new Date('2050-01-01T00:00:00Z') // eslint-disable-line camelcase
 // taken from node-forge almost not modified
 /**
  * Converts a Date object to ASN.1
  * Handles the different format before and after 1st January 2050
  *
- * @param date date object.
+ * @param {Date} date date object.
  *
  * @return the ASN.1 object representing the date.
  */
-
-const jan_1_1950 = new Date('1950-01-01T00:00:00Z')
-const jan_1_2050 = new Date('2050-01-01T00:00:00Z')
 function _dateToAsn1(date) {
+  // eslint-disable-next-line camelcase
   if (date >= jan_1_1950 && date < jan_1_2050) {
     return asn1.create(
       asn1.Class.UNIVERSAL,
@@ -144,15 +144,15 @@ function _dateToAsn1(date) {
 /**
  * Convert signature parameters object to ASN.1
  *
- * @param {String} oid Signature algorithm OID
- * @param params The signature parametrs object
+ * @param {string} oid Signature algorithm OID
+ * @param {any} params The signature parameters object
  * @return ASN.1 object representing signature parameters
  */
 function _signatureParametersToAsn1(oid, params) {
+  const parts = []
+
   switch (oid) {
     case oids['RSASSA-PSS']:
-      const parts = []
-
       if (params.hash.algorithmOid !== undefined) {
         parts.push(
           asn1.create(asn1.Class.CONTEXT_SPECIFIC, 0, true, [
@@ -217,7 +217,7 @@ function _signatureParametersToAsn1(oid, params) {
 /**
  * Gets the ASN.1 TBSCertificate part of an X.509v3 certificate.
  *
- * @param cert the certificate.
+ * @param {any} cert the certificate.
  *
  * @return the asn1 TBSCertificate.
  */
@@ -319,6 +319,10 @@ function getTBSCertificate(cert) {
 // because serial numbers use ones' complement notation
 // this RFC in section 4.1.2.2 requires serial numbers to be positive
 // http://www.ietf.org/rfc/rfc5280.txt
+/**
+ * @param {string} hexString
+ * @returns
+ */
 function toPositiveHex(hexString) {
   let mostSiginficativeHexAsInt = parseInt(hexString[0], 16)
   if (mostSiginficativeHexAsInt < 8) {
@@ -330,9 +334,21 @@ function toPositiveHex(hexString) {
 }
 
 // the next is an edit of the selfsigned function reduced to the function necessary for webtransport
+/**
+ * @typedef {object} Certificate
+ * @property {string} public
+ * @property {string} private
+ * @property {string} cert
+ * @property {Uint8Array} hash
+ * @property {string} fingerprint
+ *
+ * @param {*} attrs
+ * @param {*} options
+ * @returns {Promise<Certificate | null>}
+ */
 export async function generateWebTransportCertificate(attrs, options) {
   try {
-    let keyPair = await crypto.subtle.generateKey(
+    const keyPair = await crypto.subtle.generateKey(
       {
         name: 'ECDSA',
         namedCurve: 'P-256'
@@ -355,7 +371,7 @@ export async function generateWebTransportCertificate(attrs, options) {
     cert.setSubject(attrs)
     cert.setIssuer(attrs)
 
-    let privateKey = crypto.subtle.exportKey('pkcs8', keyPair.privateKey)
+    const privateKey = crypto.subtle.exportKey('pkcs8', keyPair.privateKey)
     const publicKey = (cert.publicKey = await crypto.subtle.exportKey(
       'spki',
       keyPair.publicKey
@@ -392,7 +408,7 @@ export async function generateWebTransportCertificate(attrs, options) {
     oids['1.2.840.10045.4.3.2'] = 'ecdsa-with-sha256'
     oids['ecdsa-with-sha256'] = '1.2.840.10045.4.3.2'
 
-    cert.siginfo.algorithmOid = cert.signatureOid = '1.2.840.10045.4.3.2' //'ecdsa-with-sha256'
+    cert.siginfo.algorithmOid = cert.signatureOid = '1.2.840.10045.4.3.2' // 'ecdsa-with-sha256'
 
     cert.tbsCertificate = getTBSCertificate(cert)
     const encoded = Buffer.from(

package/test/fixtures/chai.js

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

package/test/fixtures/read-stream.js

@@ -0,0 +1,36 @@
+/**
+ * Read a stream contents to the end and return it
+ *
+ * @template T
+ * @param {ReadableStream<T>} readable
+ * @param {number} [expected]
+ * @returns
+ */
+export async function readStream(readable, expected) {
+  const reader = readable.getReader()
+
+  try {
+    /** @type {T[]} */
+    const output = []
+
+    while (true) {
+      const { done, value } = await reader.read()
+
+      if (done) {
+        break
+      }
+
+      if (value != null) {
+        output.push(value)
+      }
+
+      if (expected != null && output.length === expected) {
+        break
+      }
+    }
+
+    return output
+  } finally {
+    reader.releaseLock()
+  }
+}

package/test/fixtures/reader-value.js

@@ -0,0 +1,24 @@
+/**
+ * @template T
+ * @param {ReadableStream<T>} readableStream
+ * @returns {Promise<T>}
+ */
+export async function getReaderValue(readableStream) {
+  const reader = readableStream.getReader()
+
+  try {
+    const { done, value } = await reader.read()
+
+    if (done) {
+      throw new Error('Stream ended')
+    }
+
+    if (!value) {
+      throw new Error('Stream value was undefined')
+    }
+
+    return value
+  } finally {
+    reader.releaseLock()
+  }
+}

package/test/fixtures/server.js

@@ -0,0 +1,58 @@
+import { generateWebTransportCertificate } from './certificate.js'
+import { Http3Server } from '../../lib/index.js'
+
+export async function createServer() {
+  const attrs = [
+    { shortName: 'C', value: 'DE' },
+    { shortName: 'ST', value: 'Berlin' },
+    { shortName: 'L', value: 'Berlin' },
+    { shortName: 'O', value: 'WebTransport Test Server' },
+    { shortName: 'CN', value: '127.0.0.1' }
+  ]
+
+  const certificate = await generateWebTransportCertificate(attrs, {
+    days: 13
+  })
+
+  if (certificate == null) {
+    throw new Error('Certificate generation failed')
+  }
+
+  const server = new Http3Server({
+    port: 0,
+    host: '127.0.0.1',
+    secret: 'mysecret',
+    cert: certificate.cert, // unclear if it is the correct format
+    privKey: certificate.private
+  })
+
+  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')
+    }
+
+    if (!value) {
+      throw new Error('Session was undefined')
+    }
+
+    return value
+  } finally {
+    sessionReader.releaseLock()
+  }
+}

package/test/fixtures/write-stream.js

@@ -0,0 +1,17 @@
+/**
+ * Write contents to a stream and close it
+ *
+ * @template T
+ * @param {WritableStream<T>} writable
+ * @param {T[]} input
+ * @returns
+ */
+export async function writeStream(writable, input) {
+  const writer = writable.getWriter()
+
+  for (const buf of input) {
+    await writer.write(buf)
+  }
+
+  await writer.close()
+}

package/test/test.js

@@ -4,8 +4,8 @@
 
 // this file runs various tests
 
-import { generateWebTransportCertificate } from './certificate.js'
-import { Http3Server, WebTransport, testcheck } from '../src/webtransport.js'
+import { generateWebTransportCertificate } from './fixtures/certificate.js'
+import { Http3Server, WebTransport, testcheck } from '../lib/index.js'
 import { echoTestsConnection, runEchoServer } from './testsuite.js'
 
 async function run() {
@@ -17,7 +17,28 @@ async function run() {
       console.log('global event loop gone, everything alright')
       process.exit(0)
     }
-  }, 40 * 1000)
+  }, 50 * 1000)
+  console.log('try connecting to server that does not exist')
+  const badClient = new WebTransport('https://127.0.0.1:49823/echo', {
+    serverCertificateHashes: [
+      {
+        algorithm: 'sha-256',
+        value: Buffer.from(
+          'a589bf4f98a0158aa890328d5d3f519b9e2a5b1e61b09eb10b7a9be0e79bf148',
+          'hex'
+        )
+      }
+    ]
+  })
+  await badClient.ready
+    .then(() => {
+      console.error('Successfully connected to a non-running server?!')
+      process.exit(1)
+    })
+    .catch(() => {
+      console.log('Did not connect to non-running server')
+    })
+
   console.log('start generating self signed certificate')
 
   const attrs = [
@@ -32,6 +53,10 @@ async function run() {
     days: 13
   })
 
+  if (certificate == null) {
+    throw new Error('Certificate generation failed')
+  }
+
   console.log('start Http3Server and startup echo tests')
   // now ramp up the server
   const http3server = new Http3Server({
@@ -52,6 +77,7 @@ async function run() {
 
   const url = 'https://127.0.0.1:8080/echo'
 
+  /** @type {import('../lib/dom').WebTransport | null} */
   let client = new WebTransport(url, {
     serverCertificateHashes: [{ algorithm: 'sha-256', value: certificate.hash }]
   })

package/test/testsuite.js

@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+/**
+ * @param {import('../lib/dom').WebTransport} session
+ */
 export async function incomingBidirectionalEchoTest(session) {
   try {
     const bidiReader = session.incomingBidirectionalStreams.getReader()
@@ -24,6 +27,9 @@ export async function incomingBidirectionalEchoTest(session) {
   }
 }
 
+/**
+ * @param {import('../lib/dom').WebTransport} session
+ */
 export async function outgoingBidirectionalEchoTest(session) {
   try {
     const mybidistream = await session.createBidirectionalStream()
@@ -33,6 +39,9 @@ export async function outgoingBidirectionalEchoTest(session) {
   }
 }
 
+/**
+ * @param {import('../lib/dom').WebTransport} session
+ */
 export async function unidirectionalEchoTest(session) {
   try {
     const unidiReader = session.incomingUnidirectionalStreams.getReader()
@@ -56,6 +65,9 @@ export async function unidirectionalEchoTest(session) {
   }
 }
 
+/**
+ * @param {import('../lib/dom').WebTransport} session
+ */
 export async function datagramEchoTest(session) {
   try {
     session.datagrams.readable.pipeTo(session.datagrams.writable)
@@ -64,6 +76,9 @@ export async function datagramEchoTest(session) {
   }
 }
 
+/**
+ * @param {import('../lib').Http3Server} server
+ */
 export async function runEchoServer(server) {
   try {
     const sessionStream = await server.sessionStream('/echo')
@@ -99,6 +114,10 @@ export async function runEchoServer(server) {
   }
 }
 
+/**
+ * @param {ArrayLike<any>} array1
+ * @param {ArrayLike<any>} array2
+ */
 function testArraysEqual(array1, array2) {
   if (array1.length !== array2.length)
     throw new Error('Array not equal in length')
@@ -107,6 +126,9 @@ function testArraysEqual(array1, array2) {
   }
 }
 
+/**
+ * @param {import('../lib/dom').WebTransport} transport
+ */
 export async function echoTestsConnection(transport) {
   // some echo tests for testing the webtransport library, not for production
   const stream = await transport.createBidirectionalStream()

package/test/unidirectional-streams.spec.js

@@ -0,0 +1,128 @@
+/* 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 'chai'
+import { readStream } from './fixtures/read-stream.js'
+import { writeStream } from './fixtures/write-stream.js'
+import { defer } from '../lib/utils.js'
+
+/**
+ * @template T
+ * @typedef {import('../lib/types').Deferred<T>} Deferred<T>
+ */
+
+const SERVER_PATH = '/unidirectional-streams'
+
+describe('unidirectional streams', function () {
+  /** @type {import('../lib/server').Http3Server} */
+  let server
+  /** @type {import('./fixtures/certificate.js').Certificate} */
+  let certificate
+  /** @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}`
+  })
+
+  afterEach(async () => {
+    if (client != null) {
+      client.close()
+    }
+
+    if (server != null) {
+      server.stopServer()
+      await server.closed
+    }
+  })
+
+  it('sends data over an outgoing unidirectional stream', async () => {
+    this.timeout(200)
+    /** @type {Deferred<Uint8Array[]>} */
+    const serverData = defer()
+
+    // 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))
+      const stream = await getReaderValue(session.incomingUnidirectionalStreams)
+
+      const output = await readStream(stream)
+      serverData.resolve(output)
+    })
+
+    // 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
+        }
+      ]
+    })
+    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,
+      'Server did not receive the same bytes we sent'
+    )
+  })
+
+  it('receives data over an incoming unidirectional stream', async () => {
+    this.timeout(200)
+    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))
+      const stream = await session.createUnidirectionalStream()
+
+      await writeStream(stream, input)
+    })
+
+    // 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
+        }
+      ]
+    })
+    await client.ready
+
+    const stream = await getReaderValue(client.incomingUnidirectionalStreams)
+    const received = await readStream(stream)
+    expect(received).to.deep.equal(
+      input,
+      'Did not receive the same bytes we sent'
+    )
+  })
+})

package/tsconfig.json

@@ -0,0 +1,40 @@
+{
+  "compilerOptions": {
+      "strict": true,
+      // project options
+      "outDir": "dist",
+      "allowJs": true,
+      "checkJs": true,
+      "target": "ES2020",
+      "module": "ES2022",
+      "lib": ["ES2021", "ES2021.Promise", "ES2021.String", "ES2020.BigInt", "DOM", "DOM.Iterable"],
+      "noEmit": false,
+      "noEmitOnError": true,
+      "emitDeclarationOnly": true,
+      "declaration": true,
+      "declarationMap": true,
+      "incremental": true,
+      "composite": true,
+      "isolatedModules": true,
+      "removeComments": false,
+      "sourceMap": true,
+      // module resolution
+      "esModuleInterop": true,
+      "moduleResolution": "node",
+      // linter checks
+      "noImplicitReturns": false,
+      "noFallthroughCasesInSwitch": true,
+      "noUnusedLocals": true,
+      "noUnusedParameters": false,
+      // advanced
+      "importsNotUsedAsValues": "error",
+      "forceConsistentCasingInFileNames": true,
+      "skipLibCheck": true,
+      "stripInternal": true,
+      "resolveJsonModule": true
+  },
+  "include": [
+      "lib",
+      "test"
+  ]
+}