@libp2p/interface-compliance-tests 1.1.9 → 1.1.13

package/src/pubsub/multiple-nodes.ts

@@ -1,29 +1,31 @@
 /* eslint max-nested-callbacks: ["error", 6] */
 import { expect } from 'aegir/utils/chai.js'
 import sinon from 'sinon'
-import delay from 'delay'
 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 { CustomEvent } from '@libp2p/interfaces'
+import { waitForSubscriptionUpdate } from './utils.js'
 import type { TestSetup } from '../index.js'
-import type { PubSub, Message, PubSubOptions } from '@libp2p/interfaces/pubsub'
+import type { Message, PubSubOptions } from '@libp2p/interfaces/pubsub'
 import type { EventMap } from './index.js'
 import type { PeerId } from '@libp2p/interfaces/src/peer-id'
-import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 import type { Registrar } from '@libp2p/interfaces/src/registrar'
-import { connectPeers, mockRegistrar } from '../mocks/registrar.js'
+import type { PubsubBaseProtocol } from '@libp2p/pubsub'
 
-export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
+export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>) => {
   describe('pubsub with multiple nodes', function () {
     describe('every peer subscribes to the topic', () => {
       describe('line', () => {
         // line
         // ◉────◉────◉
         // a    b    c
-        let psA: PubSub<EventMap>
-        let psB: PubSub<EventMap>
-        let psC: PubSub<EventMap>
+        let psA: PubsubBaseProtocol<EventMap>
+        let psB: PubsubBaseProtocol<EventMap>
+        let psC: PubsubBaseProtocol<EventMap>
         let peerIdA: PeerId
         let peerIdB: PeerId
         let peerIdC: PeerId
@@ -43,27 +45,42 @@ export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
 
           psA = await common.setup({
             peerId: peerIdA,
-            registrar: registrarA
+            registrar: registrarA,
+            emitSelf: true
           })
           psB = await common.setup({
             peerId: peerIdB,
-            registrar: registrarB
+            registrar: registrarB,
+            emitSelf: true
           })
           psC = await common.setup({
             peerId: peerIdC,
-            registrar: registrarC
+            registrar: registrarC,
+            emitSelf: true
           })
 
           // Start pubsub modes
           await Promise.all(
-            [psA, psB, psC].map((p) => p.start())
+            [psA, psB, psC].map(async (p) => await p.start())
           )
         })
 
         // Connect nodes
         beforeEach(async () => {
-          await connectPeers(psA.multicodecs[0], registrarA, registrarB, peerIdA, peerIdB)
-          await connectPeers(psB.multicodecs[0], registrarB, registrarC, peerIdB, peerIdC)
+          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
+          })
 
           // Wait for peers to be ready in pubsub
           await pWaitFor(() =>
@@ -77,7 +94,7 @@ export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
           sinon.restore()
 
           await Promise.all(
-            [psA, psB, psC].map((p) => p.stop())
+            [psA, psB, psC].map(async (p) => await p.stop())
           )
 
           await common.teardown()
@@ -89,12 +106,10 @@ export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
           psA.subscribe(topic)
           expect(psA.getTopics()).to.deep.equal([topic])
 
-          await new Promise((resolve) => psB.addEventListener('pubsub:subscription-change', resolve, {
-            once: true
-          }))
-          expect(psB.getPeers().length).to.equal(2)
+          await waitForSubscriptionUpdate(psB, psA)
 
-          expect(psB.getSubscribers(topic)).to.deep.equal([peerIdA])
+          expect(psB.getPeers().length).to.equal(2)
+          expect(psB.getSubscribers(topic).map(p => p.toString())).to.deep.equal([peerIdA.toString()])
 
           expect(psC.getPeers().length).to.equal(1)
           expect(psC.getSubscribers(topic)).to.be.empty()
@@ -106,19 +121,15 @@ export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
           expect(psB.getTopics()).to.deep.equal([topic])
 
           await Promise.all([
-            new Promise((resolve) => psA.addEventListener('pubsub:subscription-change', resolve, {
-              once: true
-            })),
-            new Promise((resolve) => psC.addEventListener('pubsub:subscription-change', resolve, {
-              once: true
-            }))
+            waitForSubscriptionUpdate(psA, psB),
+            waitForSubscriptionUpdate(psC, psB)
           ])
 
           expect(psA.getPeers().length).to.equal(1)
-          expect(psA.getSubscribers(topic)).to.deep.equal([peerIdB])
+          expect(psA.getSubscribers(topic).map(p => p.toString())).to.deep.equal([peerIdB.toString()])
 
           expect(psC.getPeers().length).to.equal(1)
-          expect(psC.getSubscribers(topic)).to.deep.equal([peerIdB])
+          expect(psC.getSubscribers(topic).map(p => p.toString())).to.deep.equal([peerIdB.toString()])
         })
 
         it('subscribe to the topic on node c', async () => {
@@ -131,7 +142,7 @@ export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
           psB.addEventListener('pubsub:subscription-change', () => {
             expect(psA.getPeers().length).to.equal(1)
             expect(psB.getPeers().length).to.equal(2)
-            expect(psB.getSubscribers(topic)).to.deep.equal([peerIdC])
+            expect(psB.getSubscribers(topic).map(p => p.toString())).to.deep.equal([peerIdC.toString()])
 
             defer.resolve()
           }, {
@@ -149,29 +160,19 @@ export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
           psB.subscribe(topic)
           psC.subscribe(topic)
 
-          // await subscription change
-          await Promise.all([
-            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
-          await delay(1000)
-
           let counter = 0
 
           psA.addEventListener(topic, incMsg)
           psB.addEventListener(topic, incMsg)
           psC.addEventListener(topic, incMsg)
 
-          void psA.publish(topic, uint8ArrayFromString('hey'))
+          await Promise.all([
+            waitForSubscriptionUpdate(psA, psB),
+            waitForSubscriptionUpdate(psB, psA),
+            waitForSubscriptionUpdate(psC, psB)
+          ])
+
+          void psA.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('hey') }))
 
           function incMsg (evt: CustomEvent<Message>) {
             const msg = evt.detail
@@ -226,10 +227,13 @@ export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
             psB.addEventListener(topic, incMsg)
             psC.addEventListener(topic, incMsg)
 
-            // await a cycle
-            await delay(1000)
+            await Promise.all([
+              waitForSubscriptionUpdate(psA, psB),
+              waitForSubscriptionUpdate(psB, psA),
+              waitForSubscriptionUpdate(psC, psB)
+            ])
 
-            void psB.publish(topic, uint8ArrayFromString('hey'))
+            void psB.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('hey') }))
 
             function incMsg (evt: CustomEvent<Message>) {
               const msg = evt.detail
@@ -259,11 +263,11 @@ export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
         //   │b     d│
         // ◉─┘       └─◉
         // a
-        let psA: PubSub<EventMap>
-        let psB: PubSub<EventMap>
-        let psC: PubSub<EventMap>
-        let psD: PubSub<EventMap>
-        let psE: PubSub<EventMap>
+        let psA: PubsubBaseProtocol<EventMap>
+        let psB: PubsubBaseProtocol<EventMap>
+        let psC: PubsubBaseProtocol<EventMap>
+        let psD: PubsubBaseProtocol<EventMap>
+        let psE: PubsubBaseProtocol<EventMap>
         let peerIdA: PeerId
         let peerIdB: PeerId
         let peerIdC: PeerId
@@ -291,37 +295,66 @@ export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
 
           psA = await common.setup({
             peerId: peerIdA,
-            registrar: registrarA
+            registrar: registrarA,
+            emitSelf: true
           })
           psB = await common.setup({
             peerId: peerIdB,
-            registrar: registrarB
+            registrar: registrarB,
+            emitSelf: true
           })
           psC = await common.setup({
             peerId: peerIdC,
-            registrar: registrarC
+            registrar: registrarC,
+            emitSelf: true
           })
           psD = await common.setup({
             peerId: peerIdD,
-            registrar: registrarD
+            registrar: registrarD,
+            emitSelf: true
           })
           psE = await common.setup({
             peerId: peerIdE,
-            registrar: registrarE
+            registrar: registrarE,
+            emitSelf: true
           })
 
           // Start pubsub nodes
           await Promise.all(
-            [psA, psB, psC, psD, psE].map((p) => p.start())
+            [psA, psB, psC, psD, psE].map(async (p) => await p.start())
           )
         })
 
         // connect nodes
         beforeEach(async () => {
-          await connectPeers(psA.multicodecs[0], registrarA, registrarB, peerIdA, peerIdB)
-          await connectPeers(psA.multicodecs[0], registrarB, registrarC, peerIdB, peerIdC)
-          await connectPeers(psA.multicodecs[0], registrarC, registrarD, peerIdC, peerIdD)
-          await connectPeers(psA.multicodecs[0], registrarD, registrarE, peerIdD, peerIdE)
+          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
+          })
 
           // Wait for peers to be ready in pubsub
           await pWaitFor(() =>
@@ -335,7 +368,7 @@ export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
 
         afterEach(async () => {
           await Promise.all(
-            [psA, psB, psC, psD, psE].map((p) => p.stop())
+            [psA, psB, psC, psD, psE].map(async (p) => await p.stop())
           )
           await common.teardown()
         })
@@ -369,17 +402,14 @@ export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
           psE.addEventListener('Z', incMsg)
 
           await Promise.all([
-            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))
+            waitForSubscriptionUpdate(psA, psB),
+            waitForSubscriptionUpdate(psB, psA),
+            waitForSubscriptionUpdate(psC, psB),
+            waitForSubscriptionUpdate(psD, psC),
+            waitForSubscriptionUpdate(psE, psD)
           ])
 
-          // await a cycle
-          await delay(1000)
-
-          void psC.publish('Z', uint8ArrayFromString('hey from c'))
+          void psC.dispatchEvent(new CustomEvent('Z', { detail: uint8ArrayFromString('hey from c') }))
 
           function incMsg (evt: CustomEvent<Message>) {
             const msg = evt.detail

package/src/pubsub/two-nodes.ts

@@ -5,13 +5,16 @@ 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 { CustomEvent } from '@libp2p/interfaces'
+import { waitForSubscriptionUpdate } from './utils.js'
 import type { TestSetup } from '../index.js'
-import type { PubSub, Message, PubSubOptions } from '@libp2p/interfaces/pubsub'
+import type { Message, PubSubOptions } from '@libp2p/interfaces/pubsub'
 import type { EventMap } from './index.js'
-import { connectPeers, mockRegistrar } from '../mocks/registrar.js'
 import type { PeerId } from '@libp2p/interfaces/src/peer-id'
 import type { Registrar } from '@libp2p/interfaces/src/registrar'
-import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+import type { PubsubBaseProtocol } from '@libp2p/pubsub'
 
 const topic = 'foo'
 
@@ -19,17 +22,17 @@ function shouldNotHappen () {
   expect.fail()
 }
 
-export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
+export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>) => {
   describe('pubsub with two nodes', () => {
-    let psA: PubSub<EventMap>
-    let psB: PubSub<EventMap>
+    let psA: PubsubBaseProtocol<EventMap>
+    let psB: PubsubBaseProtocol<EventMap>
     let peerIdA: PeerId
     let peerIdB: PeerId
     let registrarA: Registrar
     let registrarB: Registrar
 
     // Create pubsub nodes and connect them
-    before(async () => {
+    beforeEach(async () => {
       peerIdA = await createEd25519PeerId()
       peerIdB = await createEd25519PeerId()
 
@@ -38,11 +41,13 @@ export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
 
       psA = await common.setup({
         peerId: peerIdA,
-        registrar: registrarA
+        registrar: registrarA,
+        emitSelf: true
       })
       psB = await common.setup({
         peerId: peerIdB,
-        registrar: registrarB
+        registrar: registrarB,
+        emitSelf: false
       })
 
       // Start pubsub and connect nodes
@@ -52,13 +57,19 @@ export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
       expect(psA.getPeers()).to.be.empty()
       expect(psB.getPeers()).to.be.empty()
 
-      await connectPeers(psA.multicodecs[0], registrarA, registrarB, peerIdA, peerIdB)
+      await connectPeers(psA.multicodecs[0], {
+        peerId: peerIdA,
+        registrar: registrarA
+      }, {
+        peerId: peerIdB,
+        registrar: registrarB
+      })
 
       // Wait for peers to be ready in pubsub
       await pWaitFor(() => psA.getPeers().length === 1 && psB.getPeers().length === 1)
     })
 
-    after(async () => {
+    afterEach(async () => {
       sinon.restore()
 
       await psA.stop()
@@ -74,10 +85,10 @@ export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
         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)).to.deep.equal([peerIdA])
+        expect(psB.getSubscribers(topic).map(p => p.toString())).to.deep.equal([peerIdA.toString()])
         expect(changedPeerId).to.deep.equal(psB.getPeers()[0])
         expect(changedSubs).to.have.lengthOf(1)
-        expect(changedSubs[0].topicID).to.equal(topic)
+        expect(changedSubs[0].topic).to.equal(topic)
         expect(changedSubs[0].subscribe).to.equal(true)
         defer.resolve()
       }, {
@@ -104,7 +115,12 @@ export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
         once: true
       })
 
-      void psA.publish(topic, uint8ArrayFromString('hey'))
+      await Promise.all([
+        waitForSubscriptionUpdate(psA, psB),
+        waitForSubscriptionUpdate(psB, psA)
+      ])
+
+      void psA.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('hey') }))
 
       return await defer.promise
     })
@@ -133,7 +149,12 @@ export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
         once: true
       })
 
-      void psB.publish(topic, uint8ArrayFromString('banana'))
+      await Promise.all([
+        waitForSubscriptionUpdate(psA, psB),
+        waitForSubscriptionUpdate(psB, psA)
+      ])
+
+      void psB.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('banana') }))
 
       return await defer.promise
     })
@@ -150,9 +171,9 @@ export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
       function receivedMsg (evt: CustomEvent<Message>) {
         const msg = evt.detail
         expect(uint8ArrayToString(msg.data)).to.equal('banana')
-        expect(msg.from).to.deep.equal(peerIdB)
-        expect(msg.seqno).to.be.a('Uint8Array')
-        expect(msg.topicIDs).to.be.eql([topic])
+        expect(msg.from.toString()).to.equal(peerIdB.toString())
+        expect(msg.seqno).to.be.a('BigInt')
+        expect(msg.topic).to.be.equal(topic)
 
         if (++counter === 10) {
           psA.removeEventListener(topic, receivedMsg)
@@ -162,52 +183,79 @@ export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
         }
       }
 
-      Array.from({ length: 10 }, async (_, i) => await psB.publish(topic, uint8ArrayFromString('banana')))
+      await Promise.all([
+        waitForSubscriptionUpdate(psA, psB),
+        waitForSubscriptionUpdate(psB, psA)
+      ])
+
+      Array.from({ length: 10 }, (_, i) => psB.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('banana') })))
 
       return await defer.promise
     })
 
     it('Unsubscribe from topic in nodeA', async () => {
       const defer = pDefer()
-
-      psA.unsubscribe(topic)
-      expect(psA.getTopics()).to.be.empty()
+      let callCount = 0
 
       psB.addEventListener('pubsub:subscription-change', (evt) => {
-        const { peerId: changedPeerId, subscriptions: changedSubs } = evt.detail
-        expect(psB.getPeers()).to.have.lengthOf(1)
-        expect(psB.getTopics()).to.be.empty()
-        expect(changedPeerId).to.deep.equal(psB.getPeers()[0])
-        expect(changedSubs).to.have.lengthOf(1)
-        expect(changedSubs[0].topicID).to.equal(topic)
-        expect(changedSubs[0].subscribe).to.equal(false)
+        callCount++
+
+        if (callCount === 1) {
+          // notice subscribe
+          const { peerId: changedPeerId, subscriptions: changedSubs } = evt.detail
+          expect(psB.getPeers()).to.have.lengthOf(1)
+          expect(psB.getTopics()).to.be.empty()
+          expect(changedPeerId).to.deep.equal(psB.getPeers()[0])
+          expect(changedSubs).to.have.lengthOf(1)
+          expect(changedSubs[0].topic).to.equal(topic)
+          expect(changedSubs[0].subscribe).to.equal(true)
+        } else {
+          // notice unsubscribe
+          const { peerId: changedPeerId, subscriptions: changedSubs } = evt.detail
+          expect(psB.getPeers()).to.have.lengthOf(1)
+          expect(psB.getTopics()).to.be.empty()
+          expect(changedPeerId).to.deep.equal(psB.getPeers()[0])
+          expect(changedSubs).to.have.lengthOf(1)
+          expect(changedSubs[0].topic).to.equal(topic)
+          expect(changedSubs[0].subscribe).to.equal(false)
 
-        defer.resolve()
-      }, {
-        once: true
+          defer.resolve()
+        }
       })
 
+      psA.subscribe(topic)
+      expect(psA.getTopics()).to.not.be.empty()
+
+      psA.unsubscribe(topic)
+      expect(psA.getTopics()).to.be.empty()
+
       return await defer.promise
     })
 
-    it('Publish to a topic:Z in nodeA nodeB', async () => {
+    it.skip('Publish to a topic:Z in nodeA nodeB', async () => {
       const defer = pDefer()
+      const topic = 'Z'
 
-      psA.addEventListener('Z', shouldNotHappen, {
+      psA.addEventListener(topic, shouldNotHappen, {
         once: true
       })
-      psB.addEventListener('Z', shouldNotHappen, {
+      psB.addEventListener(topic, shouldNotHappen, {
         once: true
       })
 
+      await Promise.all([
+        waitForSubscriptionUpdate(psA, psB),
+        waitForSubscriptionUpdate(psB, psA)
+      ])
+
       setTimeout(() => {
-        psA.removeEventListener('Z', shouldNotHappen)
-        psB.removeEventListener('Z', shouldNotHappen)
+        psA.removeEventListener(topic, shouldNotHappen)
+        psB.removeEventListener(topic, shouldNotHappen)
         defer.resolve()
       }, 100)
 
-      void psB.publish('Z', uint8ArrayFromString('banana'))
-      void psA.publish('Z', uint8ArrayFromString('banana'))
+      void psB.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('banana') }))
+      void psA.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('banana') }))
 
       return await defer.promise
     })

package/src/pubsub/utils.ts

@@ -0,0 +1,12 @@
+import { pEvent } from 'p-event'
+import pWaitFor from 'p-wait-for'
+import type { SubscriptionChangeData } from '@libp2p/interfaces/src/pubsub'
+import type { PubsubBaseProtocol } from '@libp2p/pubsub'
+
+export async function waitForSubscriptionUpdate (a: PubsubBaseProtocol, b: PubsubBaseProtocol) {
+  await pWaitFor(async () => {
+    const event = await pEvent<'pubsub:subscription-change', CustomEvent<SubscriptionChangeData>>(a, 'pubsub:subscription-change')
+
+    return event.detail.peerId.equals(b.peerId)
+  })
+}