@libp2p/interface-compliance-tests 1.1.0 → 1.1.1

package/src/pubsub/connection-handlers.ts

@@ -7,12 +7,12 @@ 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 connection handlers', () => {
-    let psA: PubSub & Startable
-    let psB: PubSub & Startable
+    let psA: PubSub<EventMap>
+    let psB: PubSub<EventMap>
 
     describe('nodes send state on connection', () => {
       // Create pubsub nodes and connect them
@@ -48,8 +48,12 @@ export default (common: TestSetup<PubSub & Startable>) => {
         await Promise.all([
           // @ts-expect-error protected fields
           psA._libp2p.dial(psB.peerId),
-          new Promise((resolve) => psA.once('pubsub:subscription-change', resolve)),
-          new Promise((resolve) => psB.once('pubsub:subscription-change', resolve))
+          new Promise((resolve) => psA.addEventListener('pubsub:subscription-change', resolve, {
+            once: true
+          })),
+          new Promise((resolve) => psB.addEventListener('pubsub:subscription-change', resolve, {
+            once: true
+          }))
         ])
 
         expect(psA.peers.size).to.equal(1)
@@ -103,7 +107,8 @@ export default (common: TestSetup<PubSub & Startable>) => {
         let subscribedTopics = psA.getTopics()
         expect(subscribedTopics).to.not.include(topic)
 
-        psA.on(topic, (msg) => {
+        psA.addEventListener(topic, (evt) => {
+          const msg = evt.detail
           expect(msg.data).to.equalBytes(data)
           defer.resolve()
         })
@@ -174,7 +179,8 @@ export default (common: TestSetup<PubSub & Startable>) => {
         let subscribedTopics = psA.getTopics()
         expect(subscribedTopics).to.not.include(topic)
 
-        psA.on(topic, (msg) => {
+        psA.addEventListener(topic, (evt) => {
+          const msg = evt.detail
           expect(msg.data).to.equalBytes(data)
           defer.resolve()
         })
@@ -228,7 +234,8 @@ export default (common: TestSetup<PubSub & Startable>) => {
         let subscribedTopics = psA.getTopics()
         expect(subscribedTopics).to.not.include(topic)
 
-        psA.on(topic, (msg) => {
+        psA.addEventListener(topic, (evt) => {
+          const msg = evt.detail
           expect(msg.data).to.equalBytes(data)
           counter++
           counter === 1 ? defer1.resolve() : defer2.resolve()
@@ -285,7 +292,8 @@ export default (common: TestSetup<PubSub & Startable>) => {
         let bReceivedFirstMessageFromA = false
         let bReceivedSecondMessageFromA = false
 
-        const handlerSpyA = (message: Message) => {
+        const handlerSpyA = (evt: CustomEvent<Message>) => {
+          const message = evt.detail
           const data = uint8ArrayToString(message.data)
 
           if (data === 'message-from-b-1') {
@@ -296,7 +304,8 @@ export default (common: TestSetup<PubSub & Startable>) => {
             aReceivedSecondMessageFromB = true
           }
         }
-        const handlerSpyB = (message: Message) => {
+        const handlerSpyB = (evt: CustomEvent<Message>) => {
+          const message = evt.detail
           const data = uint8ArrayToString(message.data)
 
           if (data === 'message-from-a-1') {
@@ -310,8 +319,8 @@ export default (common: TestSetup<PubSub & Startable>) => {
 
         const topic = 'reconnect-channel'
 
-        psA.on(topic, handlerSpyA)
-        psB.on(topic, handlerSpyB)
+        psA.addEventListener(topic, handlerSpyA)
+        psB.addEventListener(topic, handlerSpyB)
         psA.subscribe(topic)
         psB.subscribe(topic)
 

package/src/pubsub/emit-self.ts

@@ -3,15 +3,15 @@ import sinon from 'sinon'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import type { TestSetup } from '../index.js'
 import type { PubSub, PubsubOptions } from '@libp2p/interfaces/pubsub'
-import type { Startable } from '@libp2p/interfaces'
+import type { EventMap } from './index.js'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
 const shouldNotHappen = () => expect.fail()
 
-export default (common: TestSetup<PubSub & Startable, Partial<PubsubOptions>>) => {
+export default (common: TestSetup<PubSub<EventMap>, Partial<PubsubOptions>>) => {
   describe('emit self', () => {
-    let pubsub: PubSub & Startable
+    let pubsub: PubSub<EventMap>
 
     describe('enabled', () => {
       before(async () => {
@@ -30,7 +30,9 @@ export default (common: TestSetup<PubSub & Startable, Partial<PubsubOptions>>) =
       })
 
       it('should emit to self on publish', async () => {
-        const promise = new Promise((resolve) => pubsub.once(topic, resolve))
+        const promise = new Promise((resolve) => pubsub.addEventListener(topic, resolve, {
+          once: true
+        }))
 
         void pubsub.publish(topic, data)
 
@@ -55,7 +57,9 @@ export default (common: TestSetup<PubSub & Startable, Partial<PubsubOptions>>) =
       })
 
       it('should not emit to self on publish', async () => {
-        pubsub.once(topic, () => shouldNotHappen)
+        pubsub.addEventListener(topic, () => shouldNotHappen, {
+          once: true
+        })
 
         void pubsub.publish(topic, data)
 

package/src/pubsub/index.ts

@@ -5,10 +5,17 @@ import connectionHandlersTest from './connection-handlers.js'
 import twoNodesTest from './two-nodes.js'
 import multipleNodesTest from './multiple-nodes.js'
 import type { TestSetup } from '../index.js'
-import type { PubSub } from '@libp2p/interfaces/pubsub'
-import type { Startable } from '@libp2p/interfaces'
+import type { PubSub, Message, PubsubEvents } from '@libp2p/interfaces/pubsub'
 
-export default (common: TestSetup<PubSub & Startable>) => {
+export interface EventMap extends PubsubEvents {
+  'topic': CustomEvent<Message>
+  'foo': CustomEvent<Message>
+  'test-topic': CustomEvent<Message>
+  'reconnect-channel': CustomEvent<Message>
+  'Z': CustomEvent<Message>
+}
+
+export default (common: TestSetup<PubSub<EventMap>>) => {
   describe('interface-pubsub compliance tests', () => {
     apiTest(common)
     emitSelfTest(common)

package/src/pubsub/messages.ts

@@ -6,14 +6,14 @@ import * as utils from '@libp2p/pubsub/utils'
 import { PeerStreams } from '@libp2p/pubsub/peer-streams'
 import type { TestSetup } from '../index.js'
 import type { PubSub } from '@libp2p/interfaces/pubsub'
-import type { Startable } from '@libp2p/interfaces'
+import type { EventMap } from './index.js'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
 
-export default (common: TestSetup<PubSub & Startable>) => {
+export default (common: TestSetup<PubSub<EventMap>>) => {
   describe('messages', () => {
-    let pubsub: PubSub & Startable
+    let pubsub: PubSub<EventMap>
 
     // Create pubsub router
     beforeEach(async () => {

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/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/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()
+}