@libp2p/interface-compliance-tests 1.1.14 → 1.1.17

package/src/pubsub/multiple-nodes.ts

@@ -10,22 +10,23 @@ import { connectPeers, mockRegistrar } from '../mocks/registrar.js'
 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'
-
-export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>) => {
+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'
+
+export default (common: TestSetup<PubSubBaseProtocol<EventMap>, PubSubArgs>) => {
   describe('pubsub with multiple nodes', function () {
     describe('every peer subscribes to the topic', () => {
       describe('line', () => {
         // line
         // ◉────◉────◉
         // a    b    c
-        let psA: PubsubBaseProtocol<EventMap>
-        let psB: PubsubBaseProtocol<EventMap>
-        let psC: PubsubBaseProtocol<EventMap>
+        let psA: PubSubBaseProtocol<EventMap>
+        let psB: PubSubBaseProtocol<EventMap>
+        let psC: PubSubBaseProtocol<EventMap>
         let peerIdA: PeerId
         let peerIdB: PeerId
         let peerIdC: PeerId
@@ -44,19 +45,31 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
           registrarC = 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: true
+            components: new Components({
+              peerId: peerIdB,
+              registrar: registrarB
+            }),
+            init: {
+              emitSelf: true
+            }
           })
           psC = await common.setup({
-            peerId: peerIdC,
-            registrar: registrarC,
-            emitSelf: true
+            components: new Components({
+              peerId: peerIdC,
+              registrar: registrarC
+            }),
+            init: {
+              emitSelf: true
+            }
           })
 
           // Start pubsub modes
@@ -172,7 +185,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
             waitForSubscriptionUpdate(psC, psB)
           ])
 
-          void psA.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('hey') }))
+          void psA.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('hey') }))
 
           function incMsg (evt: CustomEvent<Message>) {
             const msg = evt.detail
@@ -233,7 +246,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
               waitForSubscriptionUpdate(psC, psB)
             ])
 
-            void psB.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('hey') }))
+            void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('hey') }))
 
             function incMsg (evt: CustomEvent<Message>) {
               const msg = evt.detail
@@ -263,11 +276,11 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         //   │b     d│
         // ◉─┘       └─◉
         // a
-        let psA: PubsubBaseProtocol<EventMap>
-        let psB: PubsubBaseProtocol<EventMap>
-        let psC: PubsubBaseProtocol<EventMap>
-        let psD: PubsubBaseProtocol<EventMap>
-        let psE: PubsubBaseProtocol<EventMap>
+        let psA: PubSubBaseProtocol<EventMap>
+        let psB: PubSubBaseProtocol<EventMap>
+        let psC: PubSubBaseProtocol<EventMap>
+        let psD: PubSubBaseProtocol<EventMap>
+        let psE: PubSubBaseProtocol<EventMap>
         let peerIdA: PeerId
         let peerIdB: PeerId
         let peerIdC: PeerId
@@ -294,29 +307,49 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
           registrarE = 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: true
+            components: new Components({
+              peerId: peerIdB,
+              registrar: registrarB
+            }),
+            init: {
+              emitSelf: true
+            }
           })
           psC = await common.setup({
-            peerId: peerIdC,
-            registrar: registrarC,
-            emitSelf: true
+            components: new Components({
+              peerId: peerIdC,
+              registrar: registrarC
+            }),
+            init: {
+              emitSelf: true
+            }
           })
           psD = await common.setup({
-            peerId: peerIdD,
-            registrar: registrarD,
-            emitSelf: true
+            components: new Components({
+              peerId: peerIdD,
+              registrar: registrarD
+            }),
+            init: {
+              emitSelf: true
+            }
           })
           psE = await common.setup({
-            peerId: peerIdE,
-            registrar: registrarE,
-            emitSelf: true
+            components: new Components({
+              peerId: peerIdE,
+              registrar: registrarE
+            }),
+            init: {
+              emitSelf: true
+            }
           })
 
           // Start pubsub nodes
@@ -409,7 +442,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
             waitForSubscriptionUpdate(psE, psD)
           ])
 
-          void psC.dispatchEvent(new CustomEvent('Z', { detail: uint8ArrayFromString('hey from c') }))
+          void psC.dispatchEvent(new CustomEvent<Uint8Array>('Z', { detail: uint8ArrayFromString('hey from c') }))
 
           function incMsg (evt: CustomEvent<Message>) {
             const msg = evt.detail

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, MuxerOptions } 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, MuxerOptions>) => {
+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, MuxerOptions>) => {
     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, MuxerOptions>) => {
       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, MuxerOptions>) => {
       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, MuxerOptions } 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, MuxerOptions>) => {
+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, MuxerOptions>) => {
 
     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, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
+import type { StreamMuxerFactory } from '@libp2p/interfaces/stream-muxer'
 
-export default (common: TestSetup<Muxer, MuxerOptions>) => {
+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, MuxerOptions } 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, MuxerOptions>) => {
-  const createMuxer = async (opts?: MuxerOptions) => await common.setup(opts)
+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, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
+import type { StreamMuxer, StreamMuxerInit } from '@libp2p/interfaces/stream-muxer'
 
-export default async (createMuxer: (options?: MuxerOptions) => 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, MuxerOptions } 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, MuxerOptions>) => {
-  const createMuxer = async (opts?: MuxerOptions) => await common.setup(opts)
+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)