@fails-components/webtransport 1.1.3 → 1.2.0

package/test/index.js

@@ -1,124 +0,0 @@
-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() {
-  let http2 = false
-  if (process.argv[3] === 'http2') http2 = true
-  // eslint-disable-next-line no-unused-vars
-  return new Promise((resolve, reject) => {
-    let foundAddress = false
-
-    const server = execa('node', ['./test/fixtures/server.js'], {
-      stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
-      env: {
-        USE_HTTP2: http2 ? 'true' : 'false'
-      }
-    })
-    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]
-  let http2 = false
-  if (process.argv[3] === 'http2') http2 = true
-  let polyfill = false
-  let ponyfill = false
-  let slice = 4
-  if (process.argv.length > 3 && process.argv[4] === 'polyfill') {
-    polyfill = true
-    slice++
-    if (env === 'node') throw new Error('Polyfill not supported on node')
-  }
-  if (process.argv.length > 3 && process.argv[4] === 'ponyfill') {
-    ponyfill = true
-    slice++
-    if (env === 'node') throw new Error('Ponyfill not supported on node')
-  }
-  /** @type {string} */
-  let command = ''
-  /** @type {string[]} */
-  let args = []
-
-  if (env === 'node') {
-    command = 'mocha'
-    args = [
-      process.env.CI ? '--no-colors' : '--colors',
-      './test/*.spec.js',
-      ...process.argv.slice(4)
-    ]
-    const tests = execa(command, args, {
-      env: {
-        DEBUG_COLORS: process.env.CI ? '' : 'true',
-        CERT_HASH: certificate,
-        SERVER_URL: serverAddress,
-        USE_HTTP2: http2 ? 'true' : 'false'
-      },
-      stdio: ['inherit', 'inherit', 'inherit']
-    })
-
-    await tests
-  } else if (env === 'chromium' || env === 'firefox' || env === 'webkit') {
-    command = 'playwright-test'
-    const otheropts = []
-    if (polyfill || ponyfill || env === 'firefox')
-      otheropts.push('--config', './test/pw-no-https-errors.json')
-    args = [
-      './test/*.spec.js',
-      '-b',
-      env /* the browser */,
-      ...otheropts,
-      ...process.argv.slice(slice)
-    ]
-    const tests = execa(command, args, {
-      env: {
-        DEBUG_COLORS: process.env.CI ? '' : 'true',
-        CERT_HASH: certificate,
-        SERVER_URL: serverAddress,
-        USE_HTTP2: http2 ? 'true' : 'false',
-        USE_POLYFILL: polyfill ? 'true' : 'false',
-        USE_PONYFILL: ponyfill ? 'true' : 'false',
-        NO_CERT_HASHES:
-          env === 'firefox' && !ponyfill && !polyfill ? 'true' : 'false',
-        BROWSER: env
-      },
-      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) {
-    console.log('Error cause mocha process', err)
-    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/pw-no-https-errors.json

@@ -1,5 +0,0 @@
-{
-    "browserContextOptions": {
-        "ignoreHTTPSErrors": true
-    }
-}

package/test/session.spec.js

@@ -1,199 +0,0 @@
-/* eslint-env mocha */
-
-import { readCertHash } from './fixtures/read-cert-hash.js'
-import WebTransport from './fixtures/webtransport.js'
-import { expect } from './fixtures/chai.js'
-import { quicheLoaded } from './fixtures/quiche.js'
-import { getReaderValue } from './fixtures/reader-value.js'
-import { readStringFromStream } from './fixtures/read-stream.js'
-
-/**
- * @template T
- * @typedef {import('../lib/types').Deferred<T>} Deferred<T>
- */
-
-describe('session', function () {
-  let forceReliable = false
-  if (process.env.USE_HTTP2 === 'true') forceReliable = true
-  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'
-
-  /** @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
-  beforeEach(async () => {
-    if (
-      process.env.USE_HTTP2 !== 'true' &&
-      process.env.USE_PONYFILL !== 'true' &&
-      process.env.USE_POLYFILL !== 'true'
-    ) {
-      await quicheLoaded
-    }
-  })
-
-  // @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`,
-      wtOptions
-    )
-    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`,
-      wtOptions
-    )
-    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 parse user data', async () => {
-    client = new WebTransport(
-      `${process.env.SERVER_URL}/session_with_userdata?foo=bar`,
-      wtOptions
-    )
-    await client.ready
-
-    const stream = await getReaderValue(client.incomingUnidirectionalStreams)
-    const string = await readStringFromStream(stream)
-    const userData = JSON.parse(string)
-    expect(userData).to.have.property('search', '?foo=bar')
-  })
-
-  if (browser === 'firefox') this.timeout(31000) // really firefox?
-  it('should error when connecting to a server that does not exist', async () => {
-    client = new WebTransport(`https://127.0.0.1:39821`, {
-      quicConnectTimeout: 100,
-      webTransportConnectTimeout: 100,
-      ...wtOptions
-    })
-
-    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', handshakemess)
-    expect(readyResult)
-      .to.be.a('WebTransportError')
-      .with.property('message', handshakemess)
-  })
-
-  it('should error when connecting to a path that does not exist', async () => {
-    client = new WebTransport(
-      `${process.env.SERVER_URL}/non_existant`,
-      wtOptions
-    )
-
-    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', handshakemess)
-    expect(readyResult)
-      .to.be.a('WebTransportError')
-      .with.property('message', handshakemess)
-  })
-
-  if (
-    process.env.USE_POLYFILL !== 'true' &&
-    process.env.USE_PONYFILL !== 'true' &&
-    wtOptions.serverCertificateHashes
-  ) {
-    // deactivated in polyfill case, no test necessary
-    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')
-          }
-        ],
-        // @ts-ignore
-        forceReliable
-      })
-
-      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', handshakemess)
-      expect(readyResult)
-        .to.be.a('WebTransportError')
-        .with.property('message', handshakemess)
-    })
-
-    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)
-            )
-          }
-        ],
-        // @ts-ignore
-        forceReliable
-      })
-
-      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', handshakemess)
-      expect(readyResult)
-        .to.be.a('WebTransportError')
-        .with.property('message', handshakemess)
-    })
-  }
-})

package/test/stream-limits.spec.js

@@ -1,259 +0,0 @@
-/* eslint-env mocha */
-
-import { readCertHash } from './fixtures/read-cert-hash.js'
-import WebTransport from './fixtures/webtransport.js'
-import { expect } from './fixtures/chai.js'
-import { quicheLoaded } from './fixtures/quiche.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
-  beforeEach(async () => {
-    if (
-      process.env.USE_HTTP2 !== 'true' &&
-      process.env.USE_PONYFILL !== 'true' &&
-      process.env.USE_POLYFILL !== 'true'
-    ) {
-      await quicheLoaded
-    }
-  })
-
-  // @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', '')
-  })
-})