@fails-components/webtransport 1.1.2 → 1.1.4

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', '')
-  })
-})

package/test/unidirectional-streams.spec.js

@@ -1,133 +0,0 @@
-/* eslint-env mocha */
-
-import { getReaderValue } from './fixtures/reader-value.js'
-import WebTransport from './fixtures/webtransport.js'
-import { expect } from 'chai'
-import { readStream } from './fixtures/read-stream.js'
-import { writeStream } from './fixtures/write-stream.js'
-import { readCertHash } from './fixtures/read-cert-hash.js'
-import * as ui8 from 'uint8arrays'
-import { KNOWN_BYTES, KNOWN_BYTES_LENGTH } from './fixtures/known-bytes.js'
-import { quicheLoaded } from './fixtures/quiche.js'
-
-describe('unidirectional streams', function () {
-  /** @type {import('../lib/dom').WebTransport | undefined} */
-  let client
-  let forceReliable = false
-  if (process.env.USE_HTTP2 === 'true') forceReliable = true
-
-  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('sends data over an outgoing unidirectional stream', async () => {
-    // client context - connects to the server, opens a bidi stream, sends some data and reads the response
-    try {
-      client = new WebTransport(
-        `${process.env.SERVER_URL}/unidirectional_client_send`,
-        wtOptions
-      )
-      await client.ready
-    } catch (error) {
-      console.log('Peak unidirectional error:', error)
-      throw error
-    }
-
-    const stream = await client.createUnidirectionalStream()
-    // correct test
-    await writeStream(stream, KNOWN_BYTES)
-
-    // the remote will close the session
-    const result = await client.closed
-    client = undefined
-
-    // should receive the default close info
-    expect(result).to.have.property('reason', '')
-    expect(result).to.have.property('closeCode', 0)
-  })
-
-  it('receives data over an incoming unidirectional stream', async () => {
-    // client context - waits for the server to open a bidi stream then pipes it back to them
-    client = new WebTransport(
-      `${process.env.SERVER_URL}/unidirectional_server_send`,
-      wtOptions
-    )
-    await client.ready
-
-    const stream = await getReaderValue(client.incomingUnidirectionalStreams)
-    const output = await readStream(stream, KNOWN_BYTES_LENGTH)
-    expect(ui8.concat(KNOWN_BYTES)).to.deep.equal(
-      ui8.concat(output),
-      'Did not receive the same bytes we sent'
-    )
-  })
-
-  it('handles fin when paused due to backpressure', async function () {
-    let addpolyfill = 0
-    if (
-      process.env.USE_POLYFILL === 'true' ||
-      process.env.USE_PONYFILL === 'true'
-    )
-      addpolyfill = 4000
-    this.timeout(6000 + addpolyfill)
-    client = new WebTransport(
-      `${process.env.SERVER_URL}/unidirectional_server_delay_before_read`,
-      wtOptions
-    )
-    await client.ready
-
-    const clientStream = await client.createUnidirectionalStream()
-
-    const writer = clientStream.getWriter()
-
-    for (const buf of KNOWN_BYTES) {
-      await writer.ready
-      await writer.write(buf)
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, 2000))
-    try {
-      await writer.ready
-      await writer.close()
-    } catch (error) {
-      console.log('Ignore stop sending', error)
-    }
-
-    // the remote will close the session cleanly if everything was ok
-    await client.closed
-    client = undefined
-
-    // should receive the default close info, not true on chromium
-    // expect(result).to.have.property('reason', '')
-    // expect(result).to.have.property('closeCode', 0)
-  })
-})