@libp2p/interface-compliance-tests 1.1.15 → 1.1.16

package/src/pubsub/two-nodes.ts

@@ -10,11 +10,12 @@ import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 import { CustomEvent } from '@libp2p/interfaces'
 import { waitForSubscriptionUpdate } from './utils.js'
 import type { TestSetup } from '../index.js'
-import type { Message, PubSubOptions } from '@libp2p/interfaces/pubsub'
-import type { EventMap } from './index.js'
-import type { PeerId } from '@libp2p/interfaces/src/peer-id'
-import type { Registrar } from '@libp2p/interfaces/src/registrar'
-import type { PubsubBaseProtocol } from '@libp2p/pubsub'
+import type { Message } from '@libp2p/interfaces/pubsub'
+import type { EventMap, PubSubArgs } from './index.js'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { Registrar } from '@libp2p/interfaces/registrar'
+import type { PubSubBaseProtocol } from '@libp2p/pubsub'
+import { Components } from '@libp2p/interfaces/components'
 
 const topic = 'foo'
 
@@ -22,10 +23,10 @@ function shouldNotHappen () {
   expect.fail()
 }
 
-export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>) => {
+export default (common: TestSetup<PubSubBaseProtocol<EventMap>, PubSubArgs>) => {
   describe('pubsub with two nodes', () => {
-    let psA: PubsubBaseProtocol<EventMap>
-    let psB: PubsubBaseProtocol<EventMap>
+    let psA: PubSubBaseProtocol<EventMap>
+    let psB: PubSubBaseProtocol<EventMap>
     let peerIdA: PeerId
     let peerIdB: PeerId
     let registrarA: Registrar
@@ -40,14 +41,22 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
       registrarB = mockRegistrar()
 
       psA = await common.setup({
-        peerId: peerIdA,
-        registrar: registrarA,
-        emitSelf: true
+        components: new Components({
+          peerId: peerIdA,
+          registrar: registrarA
+        }),
+        init: {
+          emitSelf: true
+        }
       })
       psB = await common.setup({
-        peerId: peerIdB,
-        registrar: registrarB,
-        emitSelf: false
+        components: new Components({
+          peerId: peerIdB,
+          registrar: registrarB
+        }),
+        init: {
+          emitSelf: false
+        }
       })
 
       // Start pubsub and connect nodes
@@ -120,7 +129,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         waitForSubscriptionUpdate(psB, psA)
       ])
 
-      void psA.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('hey') }))
+      void psA.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('hey') }))
 
       return await defer.promise
     })
@@ -154,7 +163,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         waitForSubscriptionUpdate(psB, psA)
       ])
 
-      void psB.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('banana') }))
+      void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('banana') }))
 
       return await defer.promise
     })
@@ -172,7 +181,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         const msg = evt.detail
         expect(uint8ArrayToString(msg.data)).to.equal('banana')
         expect(msg.from.toString()).to.equal(peerIdB.toString())
-        expect(msg.seqno).to.be.a('BigInt')
+        expect(msg.sequenceNumber).to.be.a('BigInt')
         expect(msg.topic).to.be.equal(topic)
 
         if (++counter === 10) {
@@ -188,7 +197,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         waitForSubscriptionUpdate(psB, psA)
       ])
 
-      Array.from({ length: 10 }, (_, i) => psB.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('banana') })))
+      Array.from({ length: 10 }, (_, i) => psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('banana') })))
 
       return await defer.promise
     })
@@ -254,8 +263,8 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         defer.resolve()
       }, 100)
 
-      void psB.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('banana') }))
-      void psA.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('banana') }))
+      void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('banana') }))
+      void psA.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('banana') }))
 
       return await defer.promise
     })

package/src/pubsub/utils.ts

@@ -1,12 +1,12 @@
 import { pEvent } from 'p-event'
 import pWaitFor from 'p-wait-for'
-import type { SubscriptionChangeData } from '@libp2p/interfaces/src/pubsub'
-import type { PubsubBaseProtocol } from '@libp2p/pubsub'
+import type { SubscriptionChangeData } from '@libp2p/interfaces/pubsub'
+import type { PubSubBaseProtocol } from '@libp2p/pubsub'
 
-export async function waitForSubscriptionUpdate (a: PubsubBaseProtocol, b: PubsubBaseProtocol) {
+export async function waitForSubscriptionUpdate (a: PubSubBaseProtocol, b: PubSubBaseProtocol) {
   await pWaitFor(async () => {
     const event = await pEvent<'pubsub:subscription-change', CustomEvent<SubscriptionChangeData>>(a, 'pubsub:subscription-change')
 
-    return event.detail.peerId.equals(b.peerId)
+    return event.detail.peerId.equals(b.components.getPeerId())
   })
 }

package/src/stream-muxer/base-test.ts

@@ -11,22 +11,25 @@ import { isValidTick } from '../utils/is-valid-tick.js'
 import type { DeferredPromise } from 'p-defer'
 import type { TestSetup } from '../index.js'
 import type { Stream } from '@libp2p/interfaces/connection'
-import type { Muxer, MuxerInit } from '@libp2p/interfaces/stream-muxer'
+import type { StreamMuxerFactory } from '@libp2p/interfaces/stream-muxer'
 import type { Source, Duplex } from 'it-stream-types'
+import { Components } from '@libp2p/interfaces/components'
 
 async function drainAndClose (stream: Duplex<Uint8Array>) {
   return await pipe([], stream, drain)
 }
 
-export default (common: TestSetup<Muxer, MuxerInit>) => {
+export default (common: TestSetup<StreamMuxerFactory>) => {
   describe('base', () => {
     it('Open a stream from the dialer', async () => {
       const p = duplexPair<Uint8Array>()
-      const dialer = await common.setup()
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer(new Components())
       const onStreamPromise: DeferredPromise<Stream> = defer()
       const onStreamEndPromise: DeferredPromise<Stream> = defer()
 
-      const listener = await common.setup({
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer(new Components(), {
         onIncomingStream: (stream) => {
           onStreamPromise.resolve(stream)
         },
@@ -73,13 +76,15 @@ export default (common: TestSetup<Muxer, MuxerInit>) => {
     it('Open a stream from the listener', async () => {
       const p = duplexPair<Uint8Array>()
       const onStreamPromise: DeferredPromise<Stream> = defer()
-      const dialer = await common.setup({
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer(new Components(), {
         onIncomingStream: (stream: Stream) => {
           onStreamPromise.resolve(stream)
         }
       })
 
-      const listener = await common.setup()
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer(new Components())
 
       void pipe(p[0], dialer, p[0])
       void pipe(p[1], listener, p[1])
@@ -102,13 +107,15 @@ export default (common: TestSetup<Muxer, MuxerInit>) => {
       const p = duplexPair<Uint8Array>()
       const onDialerStreamPromise: DeferredPromise<Stream> = defer()
       const onListenerStreamPromise: DeferredPromise<Stream> = defer()
-      const dialer = await common.setup({
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer(new Components(), {
         onIncomingStream: (stream) => {
           onDialerStreamPromise.resolve(stream)
         }
       })
 
-      const listener = await common.setup({
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer(new Components(), {
         onIncomingStream: (stream) => {
           onListenerStreamPromise.resolve(stream)
         }
@@ -138,12 +145,14 @@ export default (common: TestSetup<Muxer, MuxerInit>) => {
       const p = duplexPair<Uint8Array>()
       const onDialerStreamPromise: DeferredPromise<Stream> = defer()
       const onListenerStreamPromise: DeferredPromise<Stream> = defer()
-      const dialer = await common.setup({
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer(new Components(), {
         onIncomingStream: (stream) => {
           onDialerStreamPromise.resolve(stream)
         }
       })
-      const listener = await common.setup({
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer(new Components(), {
         onIncomingStream: (stream) => {
           onListenerStreamPromise.resolve(stream)
         }

package/src/stream-muxer/close-test.ts

@@ -7,7 +7,8 @@ import drain from 'it-drain'
 import { expect } from 'aegir/utils/chai.js'
 import delay from 'delay'
 import type { TestSetup } from '../index.js'
-import type { Muxer, MuxerInit } from '@libp2p/interfaces/stream-muxer'
+import type { StreamMuxerFactory } from '@libp2p/interfaces/stream-muxer'
+import { Components } from '@libp2p/interfaces/components'
 
 function randomBuffer () {
   return uint8ArrayFromString(Math.random().toString())
@@ -22,15 +23,17 @@ const infiniteRandom = {
   }
 }
 
-export default (common: TestSetup<Muxer, MuxerInit>) => {
+export default (common: TestSetup<StreamMuxerFactory>) => {
   describe('close', () => {
     it('closing underlying socket closes streams', async () => {
       let openedStreams = 0
       const expectedStreams = 5
-      const dialer = await common.setup()
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer(new Components())
 
       // Listener is echo server :)
-      const listener = await common.setup({
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer(new Components(), {
         onIncomingStream: (stream) => {
           openedStreams++
           void pipe(stream, stream)
@@ -65,10 +68,12 @@ export default (common: TestSetup<Muxer, MuxerInit>) => {
 
     it('closing one of the muxed streams doesn\'t close others', async () => {
       const p = duplexPair<Uint8Array>()
-      const dialer = await common.setup()
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer(new Components())
 
       // Listener is echo server :)
-      const listener = await common.setup({
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer(new Components(), {
         onIncomingStream: (stream) => {
           void pipe(stream, stream)
         }

package/src/stream-muxer/index.ts

@@ -3,9 +3,9 @@ import closeTest from './close-test.js'
 import stressTest from './stress-test.js'
 import megaStressTest from './mega-stress-test.js'
 import type { TestSetup } from '../index.js'
-import type { Muxer, MuxerInit } from '@libp2p/interfaces/stream-muxer'
+import type { StreamMuxerFactory } from '@libp2p/interfaces/stream-muxer'
 
-export default (common: TestSetup<Muxer, MuxerInit>) => {
+export default (common: TestSetup<StreamMuxerFactory>) => {
   describe('interface-stream-muxer', () => {
     baseTest(common)
     closeTest(common)

package/src/stream-muxer/mega-stress-test.ts

@@ -1,9 +1,13 @@
 import spawn from './spawner.js'
 import type { TestSetup } from '../index.js'
-import type { Muxer, MuxerInit } from '@libp2p/interfaces/stream-muxer'
+import type { StreamMuxer, StreamMuxerFactory, StreamMuxerInit } from '@libp2p/interfaces/stream-muxer'
+import { Components } from '@libp2p/interfaces/components'
 
-export default (common: TestSetup<Muxer, MuxerInit>) => {
-  const createMuxer = async (init?: MuxerInit) => await common.setup(init)
+export default (common: TestSetup<StreamMuxerFactory>) => {
+  const createMuxer = async (init?: StreamMuxerInit): Promise<StreamMuxer> => {
+    const factory = await common.setup()
+    return factory.createStreamMuxer(new Components(), init)
+  }
 
   describe.skip('mega stress test', function () {
     it('10,000 streams with 10,000 msg', async () => await spawn(createMuxer, 10000, 10000, 5000))

package/src/stream-muxer/spawner.ts

@@ -5,9 +5,9 @@ import pLimit from 'p-limit'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import drain from 'it-drain'
 import all from 'it-all'
-import type { Muxer, MuxerInit } from '@libp2p/interfaces/stream-muxer'
+import type { StreamMuxer, StreamMuxerInit } from '@libp2p/interfaces/stream-muxer'
 
-export default async (createMuxer: (init?: MuxerInit) => Promise<Muxer>, nStreams: number, nMsg: number, limit?: number) => {
+export default async (createMuxer: (init?: StreamMuxerInit) => Promise<StreamMuxer>, nStreams: number, nMsg: number, limit?: number) => {
   const [dialerSocket, listenerSocket] = duplexPair<Uint8Array>()
 
   const msg = uint8ArrayFromString('simple msg')

package/src/stream-muxer/stress-test.ts

@@ -1,9 +1,13 @@
 import spawn from './spawner.js'
 import type { TestSetup } from '../index.js'
-import type { Muxer, MuxerInit } from '@libp2p/interfaces/stream-muxer'
+import type { StreamMuxerFactory, StreamMuxerInit, StreamMuxer } from '@libp2p/interfaces/stream-muxer'
+import { Components } from '@libp2p/interfaces/components'
 
-export default (common: TestSetup<Muxer, MuxerInit>) => {
-  const createMuxer = async (init?: MuxerInit) => await common.setup(init)
+export default (common: TestSetup<StreamMuxerFactory>) => {
+  const createMuxer = async (init?: StreamMuxerInit): Promise<StreamMuxer> => {
+    const factory = await common.setup()
+    return factory.createStreamMuxer(new Components(), init)
+  }
 
   describe('stress test', () => {
     it('1 stream with 1 msg', async () => await spawn(createMuxer, 1, 1))

package/src/transport/dial-test.ts

@@ -10,16 +10,16 @@ import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import drain from 'it-drain'
 import type { TestSetup } from '../index.js'
 import type { Transport, Listener, Upgrader } from '@libp2p/interfaces/transport'
-import type { TransportTestFixtures, SetupArgs, Connector } from './index.js'
+import type { TransportTestFixtures, Connector } from './index.js'
 import type { Multiaddr } from '@multiformats/multiaddr'
-import type { Registrar } from '@libp2p/interfaces/src/registrar'
+import type { Registrar } from '@libp2p/interfaces/registrar'
 
-export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
+export default (common: TestSetup<TransportTestFixtures>) => {
   describe('dial', () => {
     let upgrader: Upgrader
     let registrar: Registrar
     let addrs: Multiaddr[]
-    let transport: Transport<any, any>
+    let transport: Transport
     let connector: Connector
     let listener: Listener
 
@@ -29,7 +29,7 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
         registrar
       });
 
-      ({ addrs, transport, connector } = await common.setup({ upgrader }))
+      ({ addrs, transport, connector } = await common.setup())
     })
 
     after(async () => {
@@ -37,7 +37,9 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
     })
 
     beforeEach(async () => {
-      listener = transport.createListener({})
+      listener = transport.createListener({
+        upgrader
+      })
       return await listener.listen(addrs[0])
     })
 
@@ -49,17 +51,19 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
 
     it('simple', async () => {
       const protocol = '/hello/1.0.0'
-      void registrar.handle(protocol, (evt) => {
+      void registrar.handle(protocol, (data) => {
         void pipe([
           uint8ArrayFromString('hey')
         ],
-        evt.detail.stream,
+        data.stream,
         drain
         )
       })
 
       const upgradeSpy = sinon.spy(upgrader, 'upgradeOutbound')
-      const conn = await transport.dial(addrs[0])
+      const conn = await transport.dial(addrs[0], {
+        upgrader
+      })
 
       const { stream } = await conn.newStream([protocol])
       const result = await all(stream.source)
@@ -73,7 +77,9 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
 
     it('can close connections', async () => {
       const upgradeSpy = sinon.spy(upgrader, 'upgradeOutbound')
-      const conn = await transport.dial(addrs[0])
+      const conn = await transport.dial(addrs[0], {
+        upgrader
+      })
 
       expect(upgradeSpy.callCount).to.equal(1)
       await expect(upgradeSpy.getCall(0).returnValue).to.eventually.equal(conn)
@@ -84,7 +90,9 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
     it('to non existent listener', async () => {
       const upgradeSpy = sinon.spy(upgrader, 'upgradeOutbound')
 
-      await expect(transport.dial(addrs[1])).to.eventually.be.rejected()
+      await expect(transport.dial(addrs[1], {
+        upgrader
+      })).to.eventually.be.rejected()
       expect(upgradeSpy.callCount).to.equal(0)
     })
 
@@ -92,7 +100,7 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
       const upgradeSpy = sinon.spy(upgrader, 'upgradeOutbound')
       const controller = new AbortController()
       controller.abort()
-      const conn = transport.dial(addrs[0], { signal: controller.signal })
+      const conn = transport.dial(addrs[0], { signal: controller.signal, upgrader })
 
       await expect(conn).to.eventually.be.rejected().with.property('code', AbortError.code)
       expect(upgradeSpy.callCount).to.equal(0)
@@ -105,7 +113,7 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
       connector.delay(100)
 
       const controller = new AbortController()
-      const conn = transport.dial(addrs[0], { signal: controller.signal })
+      const conn = transport.dial(addrs[0], { signal: controller.signal, upgrader })
       setTimeout(() => controller.abort(), 50)
 
       await expect(conn).to.eventually.be.rejected().with.property('code', AbortError.code)

package/src/transport/filter-test.ts

@@ -1,17 +1,16 @@
 import { expect } from 'aegir/utils/chai.js'
-import { mockUpgrader } from '../mocks/upgrader.js'
 import type { TestSetup } from '../index.js'
 import type { Transport } from '@libp2p/interfaces/transport'
-import type { TransportTestFixtures, SetupArgs } from './index.js'
+import type { TransportTestFixtures } from './index.js'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
-export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
+export default (common: TestSetup<TransportTestFixtures>) => {
   describe('filter', () => {
     let addrs: Multiaddr[]
-    let transport: Transport<any, any>
+    let transport: Transport
 
     before(async () => {
-      ({ addrs, transport } = await common.setup({ upgrader: mockUpgrader() }))
+      ({ addrs, transport } = await common.setup())
     })
 
     after(async () => {

package/src/transport/index.ts

@@ -2,7 +2,7 @@ import dial from './dial-test.js'
 import listen from './listen-test.js'
 import filter from './filter-test.js'
 import type { TestSetup } from '../index.js'
-import type { Transport, Upgrader } from '@libp2p/interfaces/transport'
+import type { Transport } from '@libp2p/interfaces/transport'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 export interface Connector {
@@ -12,15 +12,11 @@ export interface Connector {
 
 export interface TransportTestFixtures {
   addrs: Multiaddr[]
-  transport: Transport<{}, {}>
+  transport: Transport
   connector: Connector
 }
 
-export interface SetupArgs {
-  upgrader: Upgrader
-}
-
-export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
+export default (common: TestSetup<TransportTestFixtures>) => {
   describe('interface-transport', () => {
     dial(common)
     listen(common)

package/src/transport/listen-test.ts

@@ -7,19 +7,18 @@ import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { isValidTick } from '../utils/is-valid-tick.js'
 import { mockUpgrader } from '../mocks/upgrader.js'
 import defer from 'p-defer'
-import { CustomEvent } from '@libp2p/interfaces'
+import { mockRegistrar } from '../mocks/registrar.js'
+import drain from 'it-drain'
 import type { TestSetup } from '../index.js'
-import type { Transport } from '@libp2p/interfaces/transport'
-import type { TransportTestFixtures, SetupArgs } from './index.js'
+import type { Transport, Upgrader } from '@libp2p/interfaces/transport'
+import type { TransportTestFixtures } from './index.js'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { Connection } from '@libp2p/interfaces/connection'
-import type { Registrar } from '@libp2p/interfaces/src/registrar'
-import { mockRegistrar } from '../mocks/registrar.js'
-import drain from 'it-drain'
+import type { Registrar } from '@libp2p/interfaces/registrar'
 
-export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
+export default (common: TestSetup<TransportTestFixtures>) => {
   describe('listen', () => {
-    let upgrader = mockUpgrader()
+    let upgrader: Upgrader
     let addrs: Multiaddr[]
     let transport: Transport
     let registrar: Registrar
@@ -30,7 +29,7 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
         registrar
       });
 
-      ({ transport, addrs } = await common.setup({ upgrader }))
+      ({ transport, addrs } = await common.setup())
     })
 
     after(async () => {
@@ -42,7 +41,9 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
     })
 
     it('simple', async () => {
-      const listener = transport.createListener()
+      const listener = transport.createListener({
+        upgrader
+      })
       await listener.listen(addrs[0])
       await listener.close()
     })
@@ -52,11 +53,12 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
       const listenerConns: Connection[] = []
 
       const protocol = '/test/protocol'
-      void registrar.handle(protocol, (evt) => {
-        void drain(evt.detail.stream.source)
+      void registrar.handle(protocol, (data) => {
+        void drain(data.stream.source)
       })
 
       const listener = transport.createListener({
+        upgrader,
         handler: (conn) => {
           listenerConns.push(conn)
         }
@@ -67,8 +69,12 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
 
       // Create two connections to the listener
       const [conn1] = await Promise.all([
-        transport.dial(addrs[0]),
-        transport.dial(addrs[0])
+        transport.dial(addrs[0], {
+          upgrader
+        }),
+        transport.dial(addrs[0], {
+          upgrader
+        })
       ])
 
       // Give the listener a chance to finish its upgrade
@@ -102,16 +108,16 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
       sinon.stub(upgrader, 'upgradeInbound').throws()
 
       const listener = transport.createListener({
-        handler: () => {
-          throw new Error('should not handle the connection if upgradeInbound throws')
-        }
+        upgrader
       })
 
       // Listen
       await listener.listen(addrs[0])
 
       // Create a connection to the listener
-      const conn = await transport.dial(addrs[0])
+      const conn = await transport.dial(addrs[0], {
+        upgrader
+      })
 
       await pWaitFor(() => typeof conn.stat.timeline.close === 'number')
       await listener.close()
@@ -120,7 +126,9 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
     describe('events', () => {
       it('connection', async () => {
         const upgradeSpy = sinon.spy(upgrader, 'upgradeInbound')
-        const listener = transport.createListener()
+        const listener = transport.createListener({
+          upgrader
+        })
         const deferred = defer()
         let conn
 
@@ -131,7 +139,9 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
 
         void (async () => {
           await listener.listen(addrs[0])
-          await transport.dial(addrs[0])
+          await transport.dial(addrs[0], {
+            upgrader
+          })
         })()
 
         await deferred.promise
@@ -142,7 +152,9 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
       })
 
       it('listening', (done) => {
-        const listener = transport.createListener()
+        const listener = transport.createListener({
+          upgrader
+        })
         listener.addEventListener('listening', () => {
           listener.close().then(done, done)
         })
@@ -150,18 +162,22 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
       })
 
       it('error', (done) => {
-        const listener = transport.createListener()
+        const listener = transport.createListener({
+          upgrader
+        })
         listener.addEventListener('error', (evt) => {
           expect(evt.detail).to.be.an.instanceOf(Error)
           listener.close().then(done, done)
         })
-        listener.dispatchEvent(new CustomEvent('error', {
-          detail: new Error('my err')
+        listener.dispatchEvent(new ErrorEvent('error', {
+          error: new Error('my err')
         }))
       })
 
       it('close', (done) => {
-        const listener = transport.createListener()
+        const listener = transport.createListener({
+          upgrader
+        })
         listener.addEventListener('close', () => done())
 
         void (async () => {