@libp2p/interface-compliance-tests 1.0.8 → 1.1.3

package/src/pubsub/multiple-nodes.ts

@@ -9,18 +9,18 @@ import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { expectSet } from './utils.js'
 import type { TestSetup } from '../index.js'
 import type { PubSub, Message } from '@libp2p/interfaces/pubsub'
-import type { Startable } from '@libp2p/interfaces'
+import type { EventMap } from './index.js'
 
-export default (common: TestSetup<PubSub & Startable>) => {
+export default (common: TestSetup<PubSub<EventMap>>) => {
   describe('pubsub with multiple nodes', function () {
     describe('every peer subscribes to the topic', () => {
       describe('line', () => {
         // line
         // ◉────◉────◉
         // a    b    c
-        let psA: PubSub & Startable
-        let psB: PubSub & Startable
-        let psC: PubSub & Startable
+        let psA: PubSub<EventMap>
+        let psB: PubSub<EventMap>
+        let psC: PubSub<EventMap>
 
         // Create and start pubsub nodes
         beforeEach(async () => {
@@ -60,7 +60,9 @@ export default (common: TestSetup<PubSub & Startable>) => {
           psA.subscribe(topic)
           expectSet(psA.subscriptions, [topic])
 
-          await new Promise((resolve) => psB.once('pubsub:subscription-change', resolve))
+          await new Promise((resolve) => psB.addEventListener('pubsub:subscription-change', resolve, {
+            once: true
+          }))
           expect(psB.peers.size).to.equal(2)
 
           const aPeerId = psA.peerId.toString()
@@ -76,8 +78,12 @@ export default (common: TestSetup<PubSub & Startable>) => {
           expectSet(psB.subscriptions, [topic])
 
           await Promise.all([
-            new Promise((resolve) => psA.once('pubsub:subscription-change', resolve)),
-            new Promise((resolve) => psC.once('pubsub:subscription-change', resolve))
+            new Promise((resolve) => psA.addEventListener('pubsub:subscription-change', resolve, {
+              once: true
+            })),
+            new Promise((resolve) => psC.addEventListener('pubsub:subscription-change', resolve, {
+              once: true
+            }))
           ])
 
           expect(psA.peers.size).to.equal(1)
@@ -94,12 +100,14 @@ export default (common: TestSetup<PubSub & Startable>) => {
           psC.subscribe(topic)
           expectSet(psC.subscriptions, [topic])
 
-          psB.once('pubsub:subscription-change', () => {
+          psB.addEventListener('pubsub:subscription-change', () => {
             expect(psA.peers.size).to.equal(1)
             expect(psB.peers.size).to.equal(2)
             expectSet(psB.topics.get(topic), [psC.peerId.toString()])
 
             defer.resolve()
+          }, {
+            once: true
           })
 
           return await defer.promise
@@ -115,9 +123,15 @@ export default (common: TestSetup<PubSub & Startable>) => {
 
           // await subscription change
           await Promise.all([
-            new Promise(resolve => psA.once('pubsub:subscription-change', () => resolve(null))),
-            new Promise(resolve => psB.once('pubsub:subscription-change', () => resolve(null))),
-            new Promise(resolve => psC.once('pubsub:subscription-change', () => resolve(null)))
+            new Promise(resolve => psA.addEventListener('pubsub:subscription-change', () => resolve(null), {
+              once: true
+            })),
+            new Promise(resolve => psB.addEventListener('pubsub:subscription-change', () => resolve(null), {
+              once: true
+            })),
+            new Promise(resolve => psC.addEventListener('pubsub:subscription-change', () => resolve(null), {
+              once: true
+            }))
           ])
 
           // await a cycle
@@ -125,22 +139,23 @@ export default (common: TestSetup<PubSub & Startable>) => {
 
           let counter = 0
 
-          psA.on(topic, incMsg)
-          psB.on(topic, incMsg)
-          psC.on(topic, incMsg)
+          psA.addEventListener(topic, incMsg)
+          psB.addEventListener(topic, incMsg)
+          psC.addEventListener(topic, incMsg)
 
           void psA.publish(topic, uint8ArrayFromString('hey'))
 
-          function incMsg (msg: Message) {
+          function incMsg (evt: CustomEvent<Message>) {
+            const msg = evt.detail
             expect(uint8ArrayToString(msg.data)).to.equal('hey')
             check()
           }
 
           function check () {
             if (++counter === 3) {
-              psA.removeListener(topic, incMsg)
-              psB.removeListener(topic, incMsg)
-              psC.removeListener(topic, incMsg)
+              psA.removeEventListener(topic, incMsg)
+              psB.removeEventListener(topic, incMsg)
+              psC.removeEventListener(topic, incMsg)
               defer.resolve()
             }
           }
@@ -168,30 +183,37 @@ export default (common: TestSetup<PubSub & Startable>) => {
 
             // await subscription change
             await Promise.all([
-              new Promise(resolve => psA.once('pubsub:subscription-change', () => resolve(null))),
-              new Promise(resolve => psB.once('pubsub:subscription-change', () => resolve(null))),
-              new Promise(resolve => psC.once('pubsub:subscription-change', () => resolve(null)))
+              new Promise(resolve => psA.addEventListener('pubsub:subscription-change', () => resolve(null), {
+                once: true
+              })),
+              new Promise(resolve => psB.addEventListener('pubsub:subscription-change', () => resolve(null), {
+                once: true
+              })),
+              new Promise(resolve => psC.addEventListener('pubsub:subscription-change', () => resolve(null), {
+                once: true
+              }))
             ])
 
-            psA.on(topic, incMsg)
-            psB.on(topic, incMsg)
-            psC.on(topic, incMsg)
+            psA.addEventListener(topic, incMsg)
+            psB.addEventListener(topic, incMsg)
+            psC.addEventListener(topic, incMsg)
 
             // await a cycle
             await delay(1000)
 
             void psB.publish(topic, uint8ArrayFromString('hey'))
 
-            function incMsg (msg: Message) {
+            function incMsg (evt: CustomEvent<Message>) {
+              const msg = evt.detail
               expect(uint8ArrayToString(msg.data)).to.equal('hey')
               check()
             }
 
             function check () {
               if (++counter === 3) {
-                psA.removeListener(topic, incMsg)
-                psB.removeListener(topic, incMsg)
-                psC.removeListener(topic, incMsg)
+                psA.removeEventListener(topic, incMsg)
+                psB.removeEventListener(topic, incMsg)
+                psC.removeEventListener(topic, incMsg)
                 defer.resolve()
               }
             }
@@ -209,11 +231,11 @@ export default (common: TestSetup<PubSub & Startable>) => {
         //   │b     d│
         // ◉─┘       └─◉
         // a
-        let psA: PubSub & Startable
-        let psB: PubSub & Startable
-        let psC: PubSub & Startable
-        let psD: PubSub & Startable
-        let psE: PubSub & Startable
+        let psA: PubSub<EventMap>
+        let psB: PubSub<EventMap>
+        let psC: PubSub<EventMap>
+        let psD: PubSub<EventMap>
+        let psE: PubSub<EventMap>
 
         // Create and start pubsub nodes
         beforeEach(async () => {
@@ -271,22 +293,22 @@ export default (common: TestSetup<PubSub & Startable>) => {
           let counter = 0
 
           psA.subscribe('Z')
-          psA.on('Z', incMsg)
+          psA.addEventListener('Z', incMsg)
           psB.subscribe('Z')
-          psB.on('Z', incMsg)
+          psB.addEventListener('Z', incMsg)
           psC.subscribe('Z')
-          psC.on('Z', incMsg)
+          psC.addEventListener('Z', incMsg)
           psD.subscribe('Z')
-          psD.on('Z', incMsg)
+          psD.addEventListener('Z', incMsg)
           psE.subscribe('Z')
-          psE.on('Z', incMsg)
+          psE.addEventListener('Z', incMsg)
 
           await Promise.all([
-            new Promise((resolve) => psA.once('pubsub:subscription-change', resolve)),
-            new Promise((resolve) => psB.once('pubsub:subscription-change', resolve)),
-            new Promise((resolve) => psC.once('pubsub:subscription-change', resolve)),
-            new Promise((resolve) => psD.once('pubsub:subscription-change', resolve)),
-            new Promise((resolve) => psE.once('pubsub:subscription-change', resolve))
+            new Promise((resolve) => psA.addEventListener('pubsub:subscription-change', resolve)),
+            new Promise((resolve) => psB.addEventListener('pubsub:subscription-change', resolve)),
+            new Promise((resolve) => psC.addEventListener('pubsub:subscription-change', resolve)),
+            new Promise((resolve) => psD.addEventListener('pubsub:subscription-change', resolve)),
+            new Promise((resolve) => psE.addEventListener('pubsub:subscription-change', resolve))
           ])
 
           // await a cycle
@@ -294,7 +316,8 @@ export default (common: TestSetup<PubSub & Startable>) => {
 
           void psC.publish('Z', uint8ArrayFromString('hey from c'))
 
-          function incMsg (msg: Message) {
+          function incMsg (evt: CustomEvent<Message>) {
+            const msg = evt.detail
             expect(uint8ArrayToString(msg.data)).to.equal('hey from c')
             check()
           }

package/src/pubsub/two-nodes.ts

@@ -11,7 +11,7 @@ import {
   first,
   expectSet
 } from './utils.js'
-import type { Startable } from '@libp2p/interfaces'
+import type { EventMap } from './index.js'
 
 const topic = 'foo'
 
@@ -19,10 +19,10 @@ function shouldNotHappen () {
   expect.fail()
 }
 
-export default (common: TestSetup<PubSub & Startable>) => {
+export default (common: TestSetup<PubSub<EventMap>>) => {
   describe('pubsub with two nodes', () => {
-    let psA: PubSub & Startable
-    let psB: PubSub & Startable
+    let psA: PubSub<EventMap>
+    let psB: PubSub<EventMap>
 
     // Create pubsub nodes and connect them
     before(async () => {
@@ -55,7 +55,8 @@ export default (common: TestSetup<PubSub & Startable>) => {
     it('Subscribe to a topic in nodeA', async () => {
       const defer = pDefer()
 
-      psB.once('pubsub:subscription-change', ({ peerId: changedPeerId, subscriptions: changedSubs }) => {
+      psB.addEventListener('pubsub:subscription-change', (evt) => {
+        const { peerId: changedPeerId, subscriptions: changedSubs } = evt.detail
         expectSet(psA.subscriptions, [topic])
         expect(psB.peers.size).to.equal(1)
         expectSet(psB.topics.get(topic), [psA.peerId.toString()])
@@ -64,6 +65,8 @@ export default (common: TestSetup<PubSub & Startable>) => {
         expect(changedSubs[0].topicID).to.equal(topic)
         expect(changedSubs[0].subscribe).to.equal(true)
         defer.resolve()
+      }, {
+        once: true
       })
       psA.subscribe(topic)
 
@@ -73,13 +76,18 @@ export default (common: TestSetup<PubSub & Startable>) => {
     it('Publish to a topic in nodeA', async () => {
       const defer = pDefer()
 
-      psA.once(topic, (msg) => {
+      psA.addEventListener(topic, (evt) => {
+        const msg = evt.detail
         expect(uint8ArrayToString(msg.data)).to.equal('hey')
-        psB.removeListener(topic, shouldNotHappen)
+        psB.removeEventListener(topic, shouldNotHappen)
         defer.resolve()
+      }, {
+        once: true
       })
 
-      psB.once(topic, shouldNotHappen)
+      psB.addEventListener(topic, shouldNotHappen, {
+        once: true
+      })
 
       void psA.publish(topic, uint8ArrayFromString('hey'))
 
@@ -89,19 +97,26 @@ export default (common: TestSetup<PubSub & Startable>) => {
     it('Publish to a topic in nodeB', async () => {
       const defer = pDefer()
 
-      psA.once(topic, (msg) => {
-        psA.once(topic, shouldNotHappen)
+      psA.addEventListener(topic, (evt) => {
+        const msg = evt.detail
+        psA.addEventListener(topic, shouldNotHappen, {
+          once: true
+        })
         expect(uint8ArrayToString(msg.data)).to.equal('banana')
 
         setTimeout(() => {
-          psA.removeListener(topic, shouldNotHappen)
-          psB.removeListener(topic, shouldNotHappen)
+          psA.removeEventListener(topic, shouldNotHappen)
+          psB.removeEventListener(topic, shouldNotHappen)
 
           defer.resolve()
         }, 100)
+      }, {
+        once: true
       })
 
-      psB.once(topic, shouldNotHappen)
+      psB.addEventListener(topic, shouldNotHappen, {
+        once: true
+      })
 
       void psB.publish(topic, uint8ArrayFromString('banana'))
 
@@ -112,18 +127,21 @@ export default (common: TestSetup<PubSub & Startable>) => {
       const defer = pDefer()
       let counter = 0
 
-      psB.once(topic, shouldNotHappen)
-      psA.on(topic, receivedMsg)
+      psB.addEventListener(topic, shouldNotHappen, {
+        once: true
+      })
+      psA.addEventListener(topic, receivedMsg)
 
-      function receivedMsg (msg: Message) {
+      function receivedMsg (evt: CustomEvent<Message>) {
+        const msg = evt.detail
         expect(uint8ArrayToString(msg.data)).to.equal('banana')
         expect(msg.from).to.be.eql(psB.peerId.toString())
         expect(msg.seqno).to.be.a('Uint8Array')
         expect(msg.topicIDs).to.be.eql([topic])
 
         if (++counter === 10) {
-          psA.removeListener(topic, receivedMsg)
-          psB.removeListener(topic, shouldNotHappen)
+          psA.removeEventListener(topic, receivedMsg)
+          psB.removeEventListener(topic, shouldNotHappen)
 
           defer.resolve()
         }
@@ -140,7 +158,8 @@ export default (common: TestSetup<PubSub & Startable>) => {
       psA.unsubscribe(topic)
       expect(psA.subscriptions.size).to.equal(0)
 
-      psB.once('pubsub:subscription-change', ({ peerId: changedPeerId, subscriptions: changedSubs }) => {
+      psB.addEventListener('pubsub:subscription-change', (evt) => {
+        const { peerId: changedPeerId, subscriptions: changedSubs } = evt.detail
         expect(psB.peers.size).to.equal(1)
         expectSet(psB.topics.get(topic), [])
         expect(changedPeerId.toString()).to.equal(first(psB.peers).id.toString())
@@ -149,6 +168,8 @@ export default (common: TestSetup<PubSub & Startable>) => {
         expect(changedSubs[0].subscribe).to.equal(false)
 
         defer.resolve()
+      }, {
+        once: true
       })
 
       return await defer.promise
@@ -157,12 +178,16 @@ export default (common: TestSetup<PubSub & Startable>) => {
     it('Publish to a topic:Z in nodeA nodeB', async () => {
       const defer = pDefer()
 
-      psA.once('Z', shouldNotHappen)
-      psB.once('Z', shouldNotHappen)
+      psA.addEventListener('Z', shouldNotHappen, {
+        once: true
+      })
+      psB.addEventListener('Z', shouldNotHappen, {
+        once: true
+      })
 
       setTimeout(() => {
-        psA.removeListener('Z', shouldNotHappen)
-        psB.removeListener('Z', shouldNotHappen)
+        psA.removeEventListener('Z', shouldNotHappen)
+        psB.removeEventListener('Z', shouldNotHappen)
         defer.resolve()
       }, 100)
 

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

@@ -10,7 +10,8 @@ import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { isValidTick } from '../transport/utils/index.js'
 import type { DeferredPromise } from 'p-defer'
 import type { TestSetup } from '../index.js'
-import type { Muxer, MuxerOptions, MuxedStream } from '@libp2p/interfaces/stream-muxer'
+import type { Stream } from '@libp2p/interfaces/connection'
+import type { Muxer, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
 import type { Source, Duplex } from 'it-stream-types'
 
 async function drainAndClose (stream: Duplex<Uint8Array>) {
@@ -22,8 +23,8 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
     it('Open a stream from the dialer', async () => {
       const p = duplexPair<Uint8Array>()
       const dialer = await common.setup()
-      const onStreamPromise: DeferredPromise<MuxedStream> = defer()
-      const onStreamEndPromise: DeferredPromise<MuxedStream> = defer()
+      const onStreamPromise: DeferredPromise<Stream> = defer()
+      const onStreamEndPromise: DeferredPromise<Stream> = defer()
 
       const listener = await common.setup({
         onStream: stream => {
@@ -71,7 +72,7 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
 
     it('Open a stream from the listener', async () => {
       const p = duplexPair<Uint8Array>()
-      const onStreamPromise: DeferredPromise<MuxedStream> = defer()
+      const onStreamPromise: DeferredPromise<Stream> = defer()
       const dialer = await common.setup({
         onStream: stream => {
           onStreamPromise.resolve(stream)
@@ -99,8 +100,8 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
 
     it('Open a stream on both sides', async () => {
       const p = duplexPair<Uint8Array>()
-      const onDialerStreamPromise: DeferredPromise<MuxedStream> = defer()
-      const onListenerStreamPromise: DeferredPromise<MuxedStream> = defer()
+      const onDialerStreamPromise: DeferredPromise<Stream> = defer()
+      const onListenerStreamPromise: DeferredPromise<Stream> = defer()
       const dialer = await common.setup({
         onStream: stream => {
           onDialerStreamPromise.resolve(stream)
@@ -134,8 +135,8 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
     it('Open a stream on one side, write, open a stream on the other side', async () => {
       const toString = (source: Source<Uint8Array>) => map(source, (u) => uint8ArrayToString(u))
       const p = duplexPair<Uint8Array>()
-      const onDialerStreamPromise: DeferredPromise<MuxedStream> = defer()
-      const onListenerStreamPromise: DeferredPromise<MuxedStream> = defer()
+      const onDialerStreamPromise: DeferredPromise<Stream> = defer()
+      const onListenerStreamPromise: DeferredPromise<Stream> = defer()
       const dialer = await common.setup({
         onStream: stream => {
           onDialerStreamPromise.resolve(stream)

package/src/transport/listen-test.ts

@@ -6,6 +6,7 @@ import { pipe } from 'it-pipe'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { isValidTick, mockUpgrader } from './utils/index.js'
 import defer from 'p-defer'
+import { CustomEvent } from '@libp2p/interfaces'
 import type { TestSetup } from '../index.js'
 import type { Transport } from '@libp2p/interfaces/transport'
 import type { TransportTestFixtures, SetupArgs } from './index.js'
@@ -108,8 +109,8 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
         const deferred = defer()
         let conn
 
-        listener.on('connection', (c) => {
-          conn = c
+        listener.addEventListener('connection', (evt) => {
+          conn = evt.detail
           deferred.resolve()
         })
 
@@ -127,7 +128,7 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
 
       it('listening', (done) => {
         const listener = transport.createListener()
-        listener.on('listening', () => {
+        listener.addEventListener('listening', () => {
           listener.close().then(done, done)
         })
         void listener.listen(addrs[0])
@@ -135,16 +136,18 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
 
       it('error', (done) => {
         const listener = transport.createListener()
-        listener.on('error', (err) => {
-          expect(err).to.exist()
+        listener.addEventListener('error', (evt) => {
+          expect(evt.detail).to.be.an.instanceOf(Error)
           listener.close().then(done, done)
         })
-        listener.emit('error', new Error('my err'))
+        listener.dispatchEvent(new CustomEvent('error', {
+          detail: new Error('my err')
+        }))
       })
 
       it('close', (done) => {
         const listener = transport.createListener()
-        listener.on('close', done)
+        listener.addEventListener('close', () => done())
 
         void (async () => {
           await listener.listen(addrs[0])

package/src/transport/utils/index.ts

@@ -7,8 +7,8 @@ import drain from 'it-drain'
 import { Multiaddr } from '@multiformats/multiaddr'
 import { pipe } from 'it-pipe'
 import type { Upgrader, MultiaddrConnection } from '@libp2p/interfaces/transport'
-import type { Connection, StreamData } from '@libp2p/interfaces/connection'
-import type { MuxedStream, Muxer } from '@libp2p/interfaces/stream-muxer'
+import type { Connection, Stream, Metadata, ProtocolStream } from '@libp2p/interfaces/connection'
+import type { Muxer } from '@libp2p/interfaces/stream-muxer'
 import type { Duplex } from 'it-stream-types'
 
 /**
@@ -46,7 +46,7 @@ export function mockMultiaddrConnection (source: Duplex<Uint8Array>): MultiaddrC
 
 export function mockMuxer (): Muxer {
   let streamId = 0
-  let streams: MuxedStream[] = []
+  let streams: Stream[] = []
   const p = pushable<Uint8Array>()
 
   const muxer: Muxer = {
@@ -61,7 +61,7 @@ export function mockMuxer (): Muxer {
       const echo = pair<Uint8Array>()
 
       const id = `${streamId++}`
-      const stream: MuxedStream = {
+      const stream: Stream = {
         id,
         sink: echo.sink,
         source: echo.source,
@@ -116,7 +116,7 @@ async function createConnection (maConn: MultiaddrConnection, direction: 'inboun
   const remotePeerIdStr = remoteAddr.getPeerId()
   const remotePeer = remotePeerIdStr != null ? PeerId.fromString(remotePeerIdStr) : await PeerIdFactory.createEd25519PeerId()
 
-  const streams: MuxedStream[] = []
+  const streams: Stream[] = []
   let streamId = 0
 
   const registry = new Map()
@@ -140,13 +140,17 @@ async function createConnection (maConn: MultiaddrConnection, direction: 'inboun
     tags: [],
     streams,
     newStream: async (protocols) => {
+      if (!Array.isArray(protocols)) {
+        protocols = [protocols]
+      }
+
       if (protocols.length === 0) {
         throw new Error('protocols must have a length')
       }
 
       const id = `${streamId++}`
-      const stream: MuxedStream = muxer.newStream(id)
-      const streamData = {
+      const stream: Stream = muxer.newStream(id)
+      const streamData: ProtocolStream = {
         protocol: protocols[0],
         stream
       }
@@ -155,7 +159,7 @@ async function createConnection (maConn: MultiaddrConnection, direction: 'inboun
 
       return streamData
     },
-    addStream: (muxedStream: MuxedStream, streamData: StreamData) => {
+    addStream: (stream: Stream, metadata: Metadata) => {
 
     },
     removeStream: (id: string) => {

package/src/utils/mock-connection-gater.ts

@@ -0,0 +1,14 @@
+
+export function mockConnectionGater () {
+  return {
+    denyDialPeer: async () => await Promise.resolve(false),
+    denyDialMultiaddr: async () => await Promise.resolve(false),
+    denyInboundConnection: async () => await Promise.resolve(false),
+    denyOutboundConnection: async () => await Promise.resolve(false),
+    denyInboundEncryptedConnection: async () => await Promise.resolve(false),
+    denyOutboundEncryptedConnection: async () => await Promise.resolve(false),
+    denyInboundUpgradedConnection: async () => await Promise.resolve(false),
+    denyOutboundUpgradedConnection: async () => await Promise.resolve(false),
+    filterMultiaddrForPeer: async () => await Promise.resolve(true)
+  }
+}

package/src/utils/mock-connection-manager.ts

@@ -0,0 +1,30 @@
+import { EventEmitter } from '@libp2p/interfaces'
+import type { Connection } from '@libp2p/interfaces/src/connection'
+import type { PeerId } from '@libp2p/interfaces/src/peer-id'
+import type { ConnectionManager, ConnectionManagerEvents } from '@libp2p/interfaces/src/registrar'
+
+class MockConnectionManager extends EventEmitter<ConnectionManagerEvents> implements ConnectionManager {
+  getConnection (peerId: PeerId): Connection | undefined {
+    throw new Error('Method not implemented.')
+  }
+
+  listenerCount (type: string): number {
+    throw new Error('Method not implemented.')
+  }
+
+  addEventListener<U extends 'peer:connect'>(type: U, callback: ((evt: ConnectionManagerEvents[U]) => void) | { handleEvent: (evt: ConnectionManagerEvents[U]) => void } | null, options?: boolean | AddEventListenerOptions): void {
+    throw new Error('Method not implemented.')
+  }
+
+  removeEventListener<U extends 'peer:connect'>(type: U, callback: (((evt: ConnectionManagerEvents[U]) => void) | { handleEvent: (evt: ConnectionManagerEvents[U]) => void } | null) | undefined, options?: boolean | EventListenerOptions): void {
+    throw new Error('Method not implemented.')
+  }
+
+  dispatchEvent (event: Event): boolean {
+    throw new Error('Method not implemented.')
+  }
+}
+
+export function mockConnectionManager () {
+  return new MockConnectionManager()
+}

package/src/utils/mock-connection.ts

@@ -0,0 +1,66 @@
+import { PeerId } from '@libp2p/peer-id'
+import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+import { pipe } from 'it-pipe'
+import type { MultiaddrConnection } from '@libp2p/interfaces/transport'
+import type { Connection, Stream, Metadata, ProtocolStream } from '@libp2p/interfaces/connection'
+import type { Muxer } from '@libp2p/interfaces/stream-muxer'
+
+export async function mockConnection (maConn: MultiaddrConnection, direction: 'inbound' | 'outbound', muxer: Muxer): Promise<Connection> {
+  const remoteAddr = maConn.remoteAddr
+  const remotePeerIdStr = remoteAddr.getPeerId()
+  const remotePeer = remotePeerIdStr != null ? PeerId.fromString(remotePeerIdStr) : await createEd25519PeerId()
+
+  const streams: Stream[] = []
+  let streamId = 0
+
+  const registry = new Map()
+
+  void pipe(
+    maConn, muxer, maConn
+  )
+
+  return {
+    id: 'mock-connection',
+    remoteAddr,
+    remotePeer,
+    stat: {
+      status: 'OPEN',
+      direction,
+      timeline: maConn.timeline,
+      multiplexer: 'test-multiplexer',
+      encryption: 'yes-yes-very-secure'
+    },
+    registry,
+    tags: [],
+    streams,
+    newStream: async (protocols) => {
+      if (!Array.isArray(protocols)) {
+        protocols = [protocols]
+      }
+
+      if (protocols.length === 0) {
+        throw new Error('protocols must have a length')
+      }
+
+      const id = `${streamId++}`
+      const stream: Stream = muxer.newStream(id)
+      const streamData: ProtocolStream = {
+        protocol: protocols[0],
+        stream
+      }
+
+      registry.set(id, streamData)
+
+      return streamData
+    },
+    addStream: (stream: Stream, metadata: Metadata) => {
+
+    },
+    removeStream: (id: string) => {
+      registry.delete(id)
+    },
+    close: async () => {
+      await maConn.close()
+    }
+  }
+}