@libp2p/interface-compliance-tests 1.1.24 → 1.1.27

package/src/pubsub/multiple-nodes.ts

@@ -5,16 +5,14 @@ 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, 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 { Components } from '@libp2p/interfaces/components'
+import type { Components } from '@libp2p/interfaces/components'
 import { start, stop } from '../index.js'
+import delay from 'delay'
 
 export default (common: TestSetup<PubSub, PubSubArgs>) => {
   describe('pubsub with multiple nodes', function () {
@@ -26,46 +24,30 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
         let psA: PubSub
         let psB: PubSub
         let psC: PubSub
-        let peerIdA: PeerId
-        let peerIdB: PeerId
-        let peerIdC: PeerId
-        let registrarA: Registrar
-        let registrarB: Registrar
-        let registrarC: Registrar
+        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
             }
@@ -77,20 +59,8 @@ export default (common: TestSetup<PubSub, 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(() =>
@@ -114,10 +84,10 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
           psA.subscribe(topic)
           expect(psA.getTopics()).to.deep.equal([topic])
 
-          await waitForSubscriptionUpdate(psB, peerIdA)
+          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()
@@ -129,15 +99,15 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
           expect(psB.getTopics()).to.deep.equal([topic])
 
           await Promise.all([
-            waitForSubscriptionUpdate(psA, peerIdB),
-            waitForSubscriptionUpdate(psC, peerIdB)
+            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 () => {
@@ -150,7 +120,7 @@ export default (common: TestSetup<PubSub, 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()
           }, {
@@ -168,55 +138,41 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
           psB.subscribe(topic)
           psC.subscribe(topic)
 
+          await Promise.all([
+            waitForSubscriptionUpdate(psA, componentsB.getPeerId()),
+            waitForSubscriptionUpdate(psB, componentsA.getPeerId()),
+            waitForSubscriptionUpdate(psC, componentsB.getPeerId())
+          ])
+
+          // GossipSub needs time to build the mesh overlay
+          await delay(1000)
+
           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, peerIdB),
-            waitForSubscriptionUpdate(psB, peerIdA),
-            waitForSubscriptionUpdate(psC, peerIdB)
-          ])
+          const result = await psA.publish(topic, uint8ArrayFromString('hey'))
 
-          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()
             }
           }
@@ -238,57 +194,41 @@ export default (common: TestSetup<PubSub, 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.subscribe(topic)
             psB.subscribe(topic)
             psC.subscribe(topic)
 
             await Promise.all([
-              waitForSubscriptionUpdate(psA, peerIdB),
-              waitForSubscriptionUpdate(psB, peerIdA),
-              waitForSubscriptionUpdate(psC, peerIdB)
+              waitForSubscriptionUpdate(psA, componentsB.getPeerId()),
+              waitForSubscriptionUpdate(psB, componentsA.getPeerId()),
+              waitForSubscriptionUpdate(psC, componentsB.getPeerId())
             ])
 
-            psB.publish(topic, uint8ArrayFromString('hey'))
+            // GossipSub needs time to build the mesh overlay
+            await delay(1000)
+
+            psA.addEventListener('message', incMsg)
+            psB.addEventListener('message', incMsg)
+            psC.addEventListener('message', incMsg)
+
+            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()
               }
             }
@@ -311,72 +251,46 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
         let psC: PubSub
         let psD: PubSub
         let psE: PubSub
-        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 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
             }
@@ -388,34 +302,10 @@ export default (common: TestSetup<PubSub, 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(() =>
@@ -451,48 +341,36 @@ export default (common: TestSetup<PubSub, 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, peerIdB),
-            waitForSubscriptionUpdate(psB, peerIdA),
-            waitForSubscriptionUpdate(psC, peerIdB),
-            waitForSubscriptionUpdate(psD, peerIdC),
-            waitForSubscriptionUpdate(psE, peerIdD)
+            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'))
+          // GossipSub needs time to build the mesh overlay
+          await delay(1000)
+
+          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,15 +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, 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 { Components } from '@libp2p/interfaces/components'
+import type { Components } from '@libp2p/interfaces/components'
 import { start, stop } from '../index.js'
 
 const topic = 'foo'
@@ -26,33 +23,22 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
   describe('pubsub with two nodes', () => {
     let psA: PubSub
     let psB: PubSub
-    let peerIdA: PeerId
-    let peerIdB: PeerId
-    let registrarA: Registrar
-    let registrarB: Registrar
+    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
         }
@@ -64,13 +50,7 @@ export default (common: TestSetup<PubSub, 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)
@@ -91,7 +71,7 @@ export default (common: TestSetup<PubSub, 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)
@@ -123,11 +103,11 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
       psB.subscribe(topic)
 
       await Promise.all([
-        waitForSubscriptionUpdate(psA, peerIdB),
-        waitForSubscriptionUpdate(psB, peerIdA)
+        waitForSubscriptionUpdate(psA, componentsB.getPeerId()),
+        waitForSubscriptionUpdate(psB, componentsA.getPeerId())
       ])
 
-      psA.publish(topic, uint8ArrayFromString('hey'))
+      await psA.publish(topic, uint8ArrayFromString('hey'))
 
       return await defer.promise
     })
@@ -166,11 +146,11 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
       psB.subscribe(topic)
 
       await Promise.all([
-        waitForSubscriptionUpdate(psA, peerIdB),
-        waitForSubscriptionUpdate(psB, peerIdA)
+        waitForSubscriptionUpdate(psA, componentsB.getPeerId()),
+        waitForSubscriptionUpdate(psB, componentsA.getPeerId())
       ])
 
-      psB.publish(topic, uint8ArrayFromString('banana'))
+      await psB.publish(topic, uint8ArrayFromString('banana'))
 
       return await defer.promise
     })
@@ -185,7 +165,7 @@ export default (common: TestSetup<PubSub, 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)
 
@@ -201,11 +181,13 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
       psB.subscribe(topic)
 
       await Promise.all([
-        waitForSubscriptionUpdate(psA, peerIdB),
-        waitForSubscriptionUpdate(psB, peerIdA)
+        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,7 +1,10 @@
 import { pEvent } from 'p-event'
 import pWaitFor from 'p-wait-for'
+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: PubSub, b: PeerId) {
   await pWaitFor(async () => {
@@ -10,3 +13,11 @@ export async function waitForSubscriptionUpdate (a: PubSub, b: PeerId) {
     return event.detail.peerId.equals(b)
   })
 }
+
+export async function createComponents (): Promise<Components> {
+  return new Components({
+    peerId: await createEd25519PeerId(),
+    registrar: mockRegistrar(),
+    connectionManager: mockConnectionManager()
+  })
+}