@libp2p/interface-compliance-tests 1.1.23 → 1.1.26

package/src/pubsub/multiple-nodes.ts

@@ -5,68 +5,48 @@ import pDefer from 'p-defer'
 import pWaitFor from 'p-wait-for'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { createEd25519PeerId } from '@libp2p/peer-id-factory'
-import { connectPeers, mockRegistrar } from '../mocks/registrar.js'
-import { waitForSubscriptionUpdate } from './utils.js'
+import { connectPeers } from '../mocks/registrar.js'
+import { createComponents, waitForSubscriptionUpdate } from './utils.js'
 import type { TestSetup } from '../index.js'
-import type { Message } from '@libp2p/interfaces/pubsub'
+import type { Message, PubSub } from '@libp2p/interfaces/pubsub'
 import type { 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'
+import type { Components } from '@libp2p/interfaces/components'
 import { start, stop } from '../index.js'
 
-export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
+export default (common: TestSetup<PubSub, PubSubArgs>) => {
   describe('pubsub with multiple nodes', function () {
     describe('every peer subscribes to the topic', () => {
       describe('line', () => {
         // line
         // ◉────◉────◉
         // a    b    c
-        let psA: PubSubBaseProtocol
-        let psB: PubSubBaseProtocol
-        let psC: PubSubBaseProtocol
-        let peerIdA: PeerId
-        let peerIdB: PeerId
-        let peerIdC: PeerId
-        let registrarA: Registrar
-        let registrarB: Registrar
-        let registrarC: Registrar
+        let psA: PubSub
+        let psB: PubSub
+        let psC: PubSub
+        let componentsA: Components
+        let componentsB: Components
+        let componentsC: Components
 
         // Create and start pubsub nodes
         beforeEach(async () => {
-          peerIdA = await createEd25519PeerId()
-          peerIdB = await createEd25519PeerId()
-          peerIdC = await createEd25519PeerId()
-
-          registrarA = mockRegistrar()
-          registrarB = mockRegistrar()
-          registrarC = mockRegistrar()
+          componentsA = await createComponents()
+          componentsB = await createComponents()
+          componentsC = await createComponents()
 
           psA = await common.setup({
-            components: new Components({
-              peerId: peerIdA,
-              registrar: registrarA
-            }),
+            components: componentsA,
             init: {
               emitSelf: true
             }
           })
           psB = await common.setup({
-            components: new Components({
-              peerId: peerIdB,
-              registrar: registrarB
-            }),
+            components: componentsB,
             init: {
               emitSelf: true
             }
           })
           psC = await common.setup({
-            components: new Components({
-              peerId: peerIdC,
-              registrar: registrarC
-            }),
+            components: componentsC,
             init: {
               emitSelf: true
             }
@@ -78,20 +58,8 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
 
         // Connect nodes
         beforeEach(async () => {
-          await connectPeers(psA.multicodecs[0], {
-            peerId: peerIdA,
-            registrar: registrarA
-          }, {
-            peerId: peerIdB,
-            registrar: registrarB
-          })
-          await connectPeers(psA.multicodecs[0], {
-            peerId: peerIdB,
-            registrar: registrarB
-          }, {
-            peerId: peerIdC,
-            registrar: registrarC
-          })
+          await connectPeers(psA.multicodecs[0], componentsA, componentsB)
+          await connectPeers(psB.multicodecs[0], componentsB, componentsC)
 
           // Wait for peers to be ready in pubsub
           await pWaitFor(() =>
@@ -115,10 +83,10 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
           psA.subscribe(topic)
           expect(psA.getTopics()).to.deep.equal([topic])
 
-          await waitForSubscriptionUpdate(psB, psA)
+          await waitForSubscriptionUpdate(psB, componentsA.getPeerId())
 
           expect(psB.getPeers().length).to.equal(2)
-          expect(psB.getSubscribers(topic).map(p => p.toString())).to.deep.equal([peerIdA.toString()])
+          expect(psB.getSubscribers(topic).map(p => p.toString())).to.deep.equal([componentsA.getPeerId().toString()])
 
           expect(psC.getPeers().length).to.equal(1)
           expect(psC.getSubscribers(topic)).to.be.empty()
@@ -130,15 +98,15 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
           expect(psB.getTopics()).to.deep.equal([topic])
 
           await Promise.all([
-            waitForSubscriptionUpdate(psA, psB),
-            waitForSubscriptionUpdate(psC, psB)
+            waitForSubscriptionUpdate(psA, componentsB.getPeerId()),
+            waitForSubscriptionUpdate(psC, componentsB.getPeerId())
           ])
 
           expect(psA.getPeers().length).to.equal(1)
-          expect(psA.getSubscribers(topic).map(p => p.toString())).to.deep.equal([peerIdB.toString()])
+          expect(psA.getSubscribers(topic).map(p => p.toString())).to.deep.equal([componentsB.getPeerId().toString()])
 
           expect(psC.getPeers().length).to.equal(1)
-          expect(psC.getSubscribers(topic).map(p => p.toString())).to.deep.equal([peerIdB.toString()])
+          expect(psC.getSubscribers(topic).map(p => p.toString())).to.deep.equal([componentsB.getPeerId().toString()])
         })
 
         it('subscribe to the topic on node c', async () => {
@@ -151,7 +119,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
           psB.addEventListener('subscription-change', () => {
             expect(psA.getPeers().length).to.equal(1)
             expect(psB.getPeers().length).to.equal(2)
-            expect(psB.getSubscribers(topic).map(p => p.toString())).to.deep.equal([peerIdC.toString()])
+            expect(psB.getSubscribers(topic).map(p => p.toString())).to.deep.equal([componentsC.getPeerId().toString()])
 
             defer.resolve()
           }, {
@@ -171,53 +139,36 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
 
           let counter = 0
 
-          psA.addEventListener('message', (evt) => {
-            if (evt.detail.topic === topic) {
-              incMsg(evt)
-            }
-          })
-          psB.addEventListener('message', (evt) => {
-            if (evt.detail.topic === topic) {
-              incMsg(evt)
-            }
-          })
-          psC.addEventListener('message', (evt) => {
-            if (evt.detail.topic === topic) {
-              incMsg(evt)
-            }
-          })
+          psA.addEventListener('message', incMsg)
+          psB.addEventListener('message', incMsg)
+          psC.addEventListener('message', incMsg)
 
           await Promise.all([
-            waitForSubscriptionUpdate(psA, psB),
-            waitForSubscriptionUpdate(psB, psA),
-            waitForSubscriptionUpdate(psC, psB)
+            waitForSubscriptionUpdate(psA, componentsB.getPeerId()),
+            waitForSubscriptionUpdate(psB, componentsA.getPeerId()),
+            waitForSubscriptionUpdate(psC, componentsB.getPeerId())
           ])
 
-          psA.publish(topic, uint8ArrayFromString('hey'))
+          const result = await psA.publish(topic, uint8ArrayFromString('hey'))
+
+          expect(result).to.have.property('recipients').with.property('length').greaterThanOrEqual(1)
 
           function incMsg (evt: CustomEvent<Message>) {
             const msg = evt.detail
+
+            if (msg.topic !== topic) {
+              return
+            }
+
             expect(uint8ArrayToString(msg.data)).to.equal('hey')
             check()
           }
 
           function check () {
             if (++counter === 3) {
-              psA.removeEventListener('message', (evt) => {
-                if (evt.detail.topic === topic) {
-                  incMsg(evt)
-                }
-              })
-              psB.removeEventListener('message', (evt) => {
-                if (evt.detail.topic === topic) {
-                  incMsg(evt)
-                }
-              })
-              psC.removeEventListener('message', (evt) => {
-                if (evt.detail.topic === topic) {
-                  incMsg(evt)
-                }
-              })
+              psA.removeEventListener('message', incMsg)
+              psB.removeEventListener('message', incMsg)
+              psC.removeEventListener('message', incMsg)
               defer.resolve()
             }
           }
@@ -239,57 +190,38 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
             const defer = pDefer()
             let counter = 0
 
-            psA.addEventListener('message', (evt) => {
-              if (evt.detail.topic === topic) {
-                incMsg(evt)
-              }
-            })
-            psB.addEventListener('message', (evt) => {
-              if (evt.detail.topic === topic) {
-                incMsg(evt)
-              }
-            })
-            psC.addEventListener('message', (evt) => {
-              if (evt.detail.topic === topic) {
-                incMsg(evt)
-              }
-            })
+            psA.addEventListener('message', incMsg)
+            psB.addEventListener('message', incMsg)
+            psC.addEventListener('message', incMsg)
 
             psA.subscribe(topic)
             psB.subscribe(topic)
             psC.subscribe(topic)
 
             await Promise.all([
-              waitForSubscriptionUpdate(psA, psB),
-              waitForSubscriptionUpdate(psB, psA),
-              waitForSubscriptionUpdate(psC, psB)
+              waitForSubscriptionUpdate(psA, componentsB.getPeerId()),
+              waitForSubscriptionUpdate(psB, componentsA.getPeerId()),
+              waitForSubscriptionUpdate(psC, componentsB.getPeerId())
             ])
 
-            psB.publish(topic, uint8ArrayFromString('hey'))
+            await psB.publish(topic, uint8ArrayFromString('hey'))
 
             function incMsg (evt: CustomEvent<Message>) {
               const msg = evt.detail
+
+              if (msg.topic !== topic) {
+                return
+              }
+
               expect(uint8ArrayToString(msg.data)).to.equal('hey')
               check()
             }
 
             function check () {
               if (++counter === 3) {
-                psA.removeEventListener('message', (evt) => {
-                  if (evt.detail.topic === topic) {
-                    incMsg(evt)
-                  }
-                })
-                psB.removeEventListener('message', (evt) => {
-                  if (evt.detail.topic === topic) {
-                    incMsg(evt)
-                  }
-                })
-                psC.removeEventListener('message', (evt) => {
-                  if (evt.detail.topic === topic) {
-                    incMsg(evt)
-                  }
-                })
+                psA.removeEventListener('message', incMsg)
+                psB.removeEventListener('message', incMsg)
+                psC.removeEventListener('message', incMsg)
                 defer.resolve()
               }
             }
@@ -307,77 +239,51 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         //   │b     d│
         // ◉─┘       └─◉
         // a
-        let psA: PubSubBaseProtocol
-        let psB: PubSubBaseProtocol
-        let psC: PubSubBaseProtocol
-        let psD: PubSubBaseProtocol
-        let psE: PubSubBaseProtocol
-        let peerIdA: PeerId
-        let peerIdB: PeerId
-        let peerIdC: PeerId
-        let peerIdD: PeerId
-        let peerIdE: PeerId
-        let registrarA: Registrar
-        let registrarB: Registrar
-        let registrarC: Registrar
-        let registrarD: Registrar
-        let registrarE: Registrar
+        let psA: PubSub
+        let psB: PubSub
+        let psC: PubSub
+        let psD: PubSub
+        let psE: PubSub
+        let componentsA: Components
+        let componentsB: Components
+        let componentsC: Components
+        let componentsD: Components
+        let componentsE: Components
 
         // Create and start pubsub nodes
         beforeEach(async () => {
-          peerIdA = await createEd25519PeerId()
-          peerIdB = await createEd25519PeerId()
-          peerIdC = await createEd25519PeerId()
-          peerIdD = await createEd25519PeerId()
-          peerIdE = await createEd25519PeerId()
-
-          registrarA = mockRegistrar()
-          registrarB = mockRegistrar()
-          registrarC = mockRegistrar()
-          registrarD = mockRegistrar()
-          registrarE = mockRegistrar()
+          componentsA = await createComponents()
+          componentsB = await createComponents()
+          componentsC = await createComponents()
+          componentsD = await createComponents()
+          componentsE = await createComponents()
 
           psA = await common.setup({
-            components: new Components({
-              peerId: peerIdA,
-              registrar: registrarA
-            }),
+            components: componentsA,
             init: {
               emitSelf: true
             }
           })
           psB = await common.setup({
-            components: new Components({
-              peerId: peerIdB,
-              registrar: registrarB
-            }),
+            components: componentsB,
             init: {
               emitSelf: true
             }
           })
           psC = await common.setup({
-            components: new Components({
-              peerId: peerIdC,
-              registrar: registrarC
-            }),
+            components: componentsC,
             init: {
               emitSelf: true
             }
           })
           psD = await common.setup({
-            components: new Components({
-              peerId: peerIdD,
-              registrar: registrarD
-            }),
+            components: componentsD,
             init: {
               emitSelf: true
             }
           })
           psE = await common.setup({
-            components: new Components({
-              peerId: peerIdE,
-              registrar: registrarE
-            }),
+            components: componentsE,
             init: {
               emitSelf: true
             }
@@ -389,34 +295,10 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
 
         // connect nodes
         beforeEach(async () => {
-          await connectPeers(psA.multicodecs[0], {
-            peerId: peerIdA,
-            registrar: registrarA
-          }, {
-            peerId: peerIdB,
-            registrar: registrarB
-          })
-          await connectPeers(psA.multicodecs[0], {
-            peerId: peerIdB,
-            registrar: registrarB
-          }, {
-            peerId: peerIdC,
-            registrar: registrarC
-          })
-          await connectPeers(psA.multicodecs[0], {
-            peerId: peerIdC,
-            registrar: registrarC
-          }, {
-            peerId: peerIdD,
-            registrar: registrarD
-          })
-          await connectPeers(psA.multicodecs[0], {
-            peerId: peerIdD,
-            registrar: registrarD
-          }, {
-            peerId: peerIdE,
-            registrar: registrarE
-          })
+          await connectPeers(psA.multicodecs[0], componentsA, componentsB)
+          await connectPeers(psA.multicodecs[0], componentsB, componentsC)
+          await connectPeers(psA.multicodecs[0], componentsC, componentsD)
+          await connectPeers(psA.multicodecs[0], componentsD, componentsE)
 
           // Wait for peers to be ready in pubsub
           await pWaitFor(() =>
@@ -452,48 +334,33 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
           const topic = 'Z'
 
           psA.subscribe(topic)
-          psA.addEventListener('message', (evt) => {
-            if (evt.detail.topic === topic) {
-              incMsg(evt)
-            }
-          })
+          psA.addEventListener('message', incMsg)
           psB.subscribe(topic)
-          psB.addEventListener('message', (evt) => {
-            if (evt.detail.topic === topic) {
-              incMsg(evt)
-            }
-          })
+          psB.addEventListener('message', incMsg)
           psC.subscribe(topic)
-          psC.addEventListener('message', (evt) => {
-            if (evt.detail.topic === topic) {
-              incMsg(evt)
-            }
-          })
+          psC.addEventListener('message', incMsg)
           psD.subscribe(topic)
-          psD.addEventListener('message', (evt) => {
-            if (evt.detail.topic === topic) {
-              incMsg(evt)
-            }
-          })
+          psD.addEventListener('message', incMsg)
           psE.subscribe(topic)
-          psE.addEventListener('message', (evt) => {
-            if (evt.detail.topic === topic) {
-              incMsg(evt)
-            }
-          })
+          psE.addEventListener('message', incMsg)
 
           await Promise.all([
-            waitForSubscriptionUpdate(psA, psB),
-            waitForSubscriptionUpdate(psB, psA),
-            waitForSubscriptionUpdate(psC, psB),
-            waitForSubscriptionUpdate(psD, psC),
-            waitForSubscriptionUpdate(psE, psD)
+            waitForSubscriptionUpdate(psA, componentsB.getPeerId()),
+            waitForSubscriptionUpdate(psB, componentsA.getPeerId()),
+            waitForSubscriptionUpdate(psC, componentsB.getPeerId()),
+            waitForSubscriptionUpdate(psD, componentsC.getPeerId()),
+            waitForSubscriptionUpdate(psE, componentsD.getPeerId())
           ])
 
-          psC.publish('Z', uint8ArrayFromString('hey from c'))
+          await psC.publish('Z', uint8ArrayFromString('hey from c'))
 
           function incMsg (evt: CustomEvent<Message>) {
             const msg = evt.detail
+
+            if (msg.topic !== topic) {
+              return
+            }
+
             expect(uint8ArrayToString(msg.data)).to.equal('hey from c')
             check()
           }

package/src/pubsub/two-nodes.ts

@@ -5,16 +5,12 @@ import pDefer from 'p-defer'
 import pWaitFor from 'p-wait-for'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { connectPeers, mockRegistrar } from '../mocks/registrar.js'
-import { createEd25519PeerId } from '@libp2p/peer-id-factory'
-import { waitForSubscriptionUpdate } from './utils.js'
+import { connectPeers } from '../mocks/registrar.js'
+import { createComponents, waitForSubscriptionUpdate } from './utils.js'
 import type { TestSetup } from '../index.js'
-import type { Message } from '@libp2p/interfaces/pubsub'
+import type { Message, PubSub } from '@libp2p/interfaces/pubsub'
 import type { 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'
+import type { Components } from '@libp2p/interfaces/components'
 import { start, stop } from '../index.js'
 
 const topic = 'foo'
@@ -23,37 +19,26 @@ function shouldNotHappen () {
   expect.fail()
 }
 
-export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
+export default (common: TestSetup<PubSub, PubSubArgs>) => {
   describe('pubsub with two nodes', () => {
-    let psA: PubSubBaseProtocol
-    let psB: PubSubBaseProtocol
-    let peerIdA: PeerId
-    let peerIdB: PeerId
-    let registrarA: Registrar
-    let registrarB: Registrar
+    let psA: PubSub
+    let psB: PubSub
+    let componentsA: Components
+    let componentsB: Components
 
     // Create pubsub nodes and connect them
     beforeEach(async () => {
-      peerIdA = await createEd25519PeerId()
-      peerIdB = await createEd25519PeerId()
-
-      registrarA = mockRegistrar()
-      registrarB = mockRegistrar()
+      componentsA = await createComponents()
+      componentsB = await createComponents()
 
       psA = await common.setup({
-        components: new Components({
-          peerId: peerIdA,
-          registrar: registrarA
-        }),
+        components: componentsA,
         init: {
           emitSelf: true
         }
       })
       psB = await common.setup({
-        components: new Components({
-          peerId: peerIdB,
-          registrar: registrarB
-        }),
+        components: componentsB,
         init: {
           emitSelf: false
         }
@@ -65,13 +50,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
       expect(psA.getPeers()).to.be.empty()
       expect(psB.getPeers()).to.be.empty()
 
-      await connectPeers(psA.multicodecs[0], {
-        peerId: peerIdA,
-        registrar: registrarA
-      }, {
-        peerId: peerIdB,
-        registrar: registrarB
-      })
+      await connectPeers(psA.multicodecs[0], componentsA, componentsB)
 
       // Wait for peers to be ready in pubsub
       await pWaitFor(() => psA.getPeers().length === 1 && psB.getPeers().length === 1)
@@ -92,7 +71,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         const { peerId: changedPeerId, subscriptions: changedSubs } = evt.detail
         expect(psA.getTopics()).to.deep.equal([topic])
         expect(psB.getPeers()).to.have.lengthOf(1)
-        expect(psB.getSubscribers(topic).map(p => p.toString())).to.deep.equal([peerIdA.toString()])
+        expect(psB.getSubscribers(topic).map(p => p.toString())).to.deep.equal([componentsA.getPeerId().toString()])
         expect(changedPeerId).to.deep.equal(psB.getPeers()[0])
         expect(changedSubs).to.have.lengthOf(1)
         expect(changedSubs[0].topic).to.equal(topic)
@@ -124,11 +103,11 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
       psB.subscribe(topic)
 
       await Promise.all([
-        waitForSubscriptionUpdate(psA, psB),
-        waitForSubscriptionUpdate(psB, psA)
+        waitForSubscriptionUpdate(psA, componentsB.getPeerId()),
+        waitForSubscriptionUpdate(psB, componentsA.getPeerId())
       ])
 
-      psA.publish(topic, uint8ArrayFromString('hey'))
+      await psA.publish(topic, uint8ArrayFromString('hey'))
 
       return await defer.promise
     })
@@ -167,11 +146,11 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
       psB.subscribe(topic)
 
       await Promise.all([
-        waitForSubscriptionUpdate(psA, psB),
-        waitForSubscriptionUpdate(psB, psA)
+        waitForSubscriptionUpdate(psA, componentsB.getPeerId()),
+        waitForSubscriptionUpdate(psB, componentsA.getPeerId())
       ])
 
-      psB.publish(topic, uint8ArrayFromString('banana'))
+      await psB.publish(topic, uint8ArrayFromString('banana'))
 
       return await defer.promise
     })
@@ -186,7 +165,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
       function receivedMsg (evt: CustomEvent<Message>) {
         const msg = evt.detail
         expect(uint8ArrayToString(msg.data)).to.equal('banana')
-        expect(msg.from.toString()).to.equal(peerIdB.toString())
+        expect(msg.from.toString()).to.equal(componentsB.getPeerId().toString())
         expect(msg.sequenceNumber).to.be.a('BigInt')
         expect(msg.topic).to.be.equal(topic)
 
@@ -202,11 +181,13 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
       psB.subscribe(topic)
 
       await Promise.all([
-        waitForSubscriptionUpdate(psA, psB),
-        waitForSubscriptionUpdate(psB, psA)
+        waitForSubscriptionUpdate(psA, componentsB.getPeerId()),
+        waitForSubscriptionUpdate(psB, componentsA.getPeerId())
       ])
 
-      Array.from({ length: 10 }, (_, i) => psB.publish(topic, uint8ArrayFromString('banana')))
+      await Promise.all(
+        Array.from({ length: 10 }, async (_, i) => await psB.publish(topic, uint8ArrayFromString('banana')))
+      )
 
       return await defer.promise
     })

package/src/pubsub/utils.ts

@@ -1,12 +1,23 @@
 import { pEvent } from 'p-event'
 import pWaitFor from 'p-wait-for'
-import type { SubscriptionChangeData } from '@libp2p/interfaces/pubsub'
-import type { PubSubBaseProtocol } from '@libp2p/pubsub'
+import { Components } from '@libp2p/interfaces/components'
+import type { PubSub, SubscriptionChangeData } from '@libp2p/interfaces/pubsub'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+import { mockConnectionManager, mockRegistrar } from '../mocks/index.js'
 
-export async function waitForSubscriptionUpdate (a: PubSubBaseProtocol, b: PubSubBaseProtocol) {
+export async function waitForSubscriptionUpdate (a: PubSub, b: PeerId) {
   await pWaitFor(async () => {
     const event = await pEvent<'subscription-change', CustomEvent<SubscriptionChangeData>>(a, 'subscription-change')
 
-    return event.detail.peerId.equals(b.components.getPeerId())
+    return event.detail.peerId.equals(b)
+  })
+}
+
+export async function createComponents (): Promise<Components> {
+  return new Components({
+    peerId: await createEd25519PeerId(),
+    registrar: mockRegistrar(),
+    connectionManager: mockConnectionManager()
   })
 }