@libp2p/interface-compliance-tests 1.1.6 → 1.1.10

package/src/pubsub/messages.ts

@@ -1,23 +1,33 @@
 import { expect } from 'aegir/utils/chai.js'
 import sinon from 'sinon'
-import * as PeerIdFactory from '@libp2p/peer-id-factory'
+import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import * as utils from '@libp2p/pubsub/utils'
+import { noSignMsgId } from '@libp2p/pubsub/utils'
 import { PeerStreams } from '@libp2p/pubsub/peer-streams'
+import { mockRegistrar } from '../mocks/registrar.js'
+import pDefer from 'p-defer'
+import delay from 'delay'
+import pWaitFor from 'p-wait-for'
+import { CustomEvent } from '@libp2p/interfaces'
 import type { TestSetup } from '../index.js'
-import type { PubSub } from '@libp2p/interfaces/pubsub'
+import type { PubSubOptions, RPC } from '@libp2p/interfaces/pubsub'
 import type { EventMap } from './index.js'
+import type { PubsubBaseProtocol } from '@libp2p/pubsub'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
 
-export default (common: TestSetup<PubSub<EventMap>>) => {
+export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>) => {
   describe('messages', () => {
-    let pubsub: PubSub<EventMap>
+    let pubsub: PubsubBaseProtocol<EventMap>
 
     // Create pubsub router
     beforeEach(async () => {
-      pubsub = await common.setup()
+      pubsub = await common.setup({
+        peerId: await createEd25519PeerId(),
+        registrar: mockRegistrar(),
+        emitSelf: true
+      })
       await pubsub.start()
     })
 
@@ -29,83 +39,88 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
 
     it('should emit normalized signed messages on publish', async () => {
       pubsub.globalSignaturePolicy = 'StrictSign'
-      // @ts-expect-error protected field
-      sinon.spy(pubsub, '_emitMessage')
 
-      await pubsub.publish(topic, data)
-      // @ts-expect-error protected field
-      expect(pubsub._emitMessage.callCount).to.eql(1)
-      // @ts-expect-error protected field
-      const [messageToEmit] = pubsub._emitMessage.getCall(0).args
+      const spy = sinon.spy(pubsub, 'publishMessage')
+
+      await pubsub.dispatchEvent(new CustomEvent(topic, { detail: data }))
+
+      await pWaitFor(async () => {
+        return spy.callCount === 1
+      })
+
+      expect(spy).to.have.property('callCount', 1)
+
+      const [from, messageToEmit] = spy.getCall(0).args
 
+      expect(from.toString()).to.equal(pubsub.peerId.toString())
       expect(messageToEmit.seqno).to.not.eql(undefined)
       expect(messageToEmit.key).to.not.eql(undefined)
       expect(messageToEmit.signature).to.not.eql(undefined)
     })
 
     it('should drop unsigned messages', async () => {
-      // @ts-expect-error protected field
-      sinon.spy(pubsub, '_emitMessage')
-      // @ts-expect-error protected field
-      sinon.spy(pubsub, '_publish')
+      const publishSpy = sinon.spy(pubsub, 'publishMessage')
       sinon.spy(pubsub, 'validate')
 
       const peerStream = new PeerStreams({
-        id: await PeerIdFactory.createEd25519PeerId(),
+        id: await createEd25519PeerId(),
         protocol: 'test'
       })
-      const rpc = {
+      const rpc: RPC = {
         subscriptions: [],
-        msgs: [{
-          receivedFrom: peerStream.id.toString(),
+        messages: [{
           from: peerStream.id.toBytes(),
           data,
-          seqno: utils.randomSeqno(),
-          topicIDs: [topic]
+          seqno: await noSignMsgId(data),
+          topic: topic
         }]
       }
 
       pubsub.subscribe(topic)
-      // @ts-expect-error protected field
-      await pubsub._processRpc(peerStream.id.toString(), peerStream, rpc)
 
-      expect(pubsub.validate).to.have.property('callCount', 1)
-      // @ts-expect-error protected field
-      expect(pubsub._emitMessage).to.have.property('called', false)
-      // @ts-expect-error protected field
-      expect(pubsub._publish).to.have.property('called', false)
+      await pubsub.processRpc(peerStream.id, peerStream, rpc)
+
+      // message should not be delivered
+      await delay(1000)
+
+      expect(publishSpy).to.have.property('called', false)
     })
 
     it('should not drop unsigned messages if strict signing is disabled', async () => {
       pubsub.globalSignaturePolicy = 'StrictNoSign'
-      // @ts-expect-error protected field
-      sinon.spy(pubsub, '_emitMessage')
-      // @ts-expect-error protected field
-      sinon.spy(pubsub, '_publish')
+
+      const publishSpy = sinon.spy(pubsub, 'publishMessage')
       sinon.spy(pubsub, 'validate')
 
       const peerStream = new PeerStreams({
-        id: await PeerIdFactory.createEd25519PeerId(),
+        id: await createEd25519PeerId(),
         protocol: 'test'
       })
 
-      const rpc = {
+      const rpc: RPC = {
         subscriptions: [],
-        msgs: [{
+        messages: [{
+          from: peerStream.id.toBytes(),
           data,
-          topicIDs: [topic]
+          topic
         }]
       }
 
       pubsub.subscribe(topic)
-      // @ts-expect-error protected field
-      await pubsub._processRpc(peerStream.id.toString(), peerStream, rpc)
+
+      const deferred = pDefer()
+
+      pubsub.addEventListener(topic, () => {
+        deferred.resolve()
+      })
+
+      await pubsub.processRpc(peerStream.id, peerStream, rpc)
+
+      // await message delivery
+      await deferred.promise
 
       expect(pubsub.validate).to.have.property('callCount', 1)
-      // @ts-expect-error protected field
-      expect(pubsub._emitMessage).to.have.property('called', 1)
-      // @ts-expect-error protected field
-      expect(pubsub._publish).to.have.property('called', 1)
+      expect(publishSpy).to.have.property('callCount', 1)
     })
   })
 }

package/src/pubsub/multiple-nodes.ts

@@ -6,51 +6,97 @@ 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 { expectSet } from './utils.js'
+import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+import { connectPeers, mockRegistrar } from '../mocks/registrar.js'
+import { CustomEvent } from '@libp2p/interfaces'
 import type { TestSetup } from '../index.js'
-import type { PubSub, Message } 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 type { Registrar } from '@libp2p/interfaces/src/registrar'
+import type { PubsubBaseProtocol } from '@libp2p/pubsub'
 
-export default (common: TestSetup<PubSub<EventMap>>) => {
+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
+        let registrarA: Registrar
+        let registrarB: Registrar
+        let registrarC: Registrar
 
         // Create and start pubsub nodes
         beforeEach(async () => {
-          psA = await common.setup()
-          psB = await common.setup()
-          psC = await common.setup()
+          peerIdA = await createEd25519PeerId()
+          peerIdB = await createEd25519PeerId()
+          peerIdC = await createEd25519PeerId()
+
+          registrarA = mockRegistrar()
+          registrarB = mockRegistrar()
+          registrarC = mockRegistrar()
+
+          psA = await common.setup({
+            peerId: peerIdA,
+            registrar: registrarA,
+            emitSelf: true
+          })
+          psB = await common.setup({
+            peerId: peerIdB,
+            registrar: registrarB,
+            emitSelf: true
+          })
+          psC = await common.setup({
+            peerId: peerIdC,
+            registrar: registrarC,
+            emitSelf: true
+          })
 
           // Start pubsub modes
-          ;[psA, psB, psC].map((p) => p.start())
+          await Promise.all(
+            [psA, psB, psC].map(async (p) => await p.start())
+          )
         })
 
         // Connect nodes
         beforeEach(async () => {
-          // @ts-expect-error protected field
-          await psA._libp2p.dial(psB.peerId)
-          // @ts-expect-error protected field
-          await psB._libp2p.dial(psC.peerId)
+          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(() =>
-            psA.peers.size === 1 &&
-            psC.peers.size === 1 &&
-            psA.peers.size === 1
+            psA.getPeers().length === 1 &&
+            psC.getPeers().length === 1 &&
+            psA.getPeers().length === 1
           )
         })
 
         afterEach(async () => {
           sinon.restore()
 
-          ;[psA, psB, psC].map((p) => p.stop())
+          await Promise.all(
+            [psA, psB, psC].map(async (p) => await p.stop())
+          )
+
           await common.teardown()
         })
 
@@ -58,24 +104,23 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
           const topic = 'Z'
 
           psA.subscribe(topic)
-          expectSet(psA.subscriptions, [topic])
+          expect(psA.getTopics()).to.deep.equal([topic])
 
           await new Promise((resolve) => psB.addEventListener('pubsub:subscription-change', resolve, {
             once: true
           }))
-          expect(psB.peers.size).to.equal(2)
+          expect(psB.getPeers().length).to.equal(2)
 
-          const aPeerId = psA.peerId.toString()
-          expectSet(psB.topics.get(topic), [aPeerId])
+          expect(psB.getSubscribers(topic).map(p => p.toString())).to.deep.equal([peerIdA.toString()])
 
-          expect(psC.peers.size).to.equal(1)
-          expect(psC.topics.get(topic)).to.eql(undefined)
+          expect(psC.getPeers().length).to.equal(1)
+          expect(psC.getSubscribers(topic)).to.be.empty()
         })
 
         it('subscribe to the topic on node b', async () => {
           const topic = 'Z'
           psB.subscribe(topic)
-          expectSet(psB.subscriptions, [topic])
+          expect(psB.getTopics()).to.deep.equal([topic])
 
           await Promise.all([
             new Promise((resolve) => psA.addEventListener('pubsub:subscription-change', resolve, {
@@ -86,11 +131,11 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
             }))
           ])
 
-          expect(psA.peers.size).to.equal(1)
-          expectSet(psA.topics.get(topic), [psB.peerId.toString()])
+          expect(psA.getPeers().length).to.equal(1)
+          expect(psA.getSubscribers(topic).map(p => p.toString())).to.deep.equal([peerIdB.toString()])
 
-          expect(psC.peers.size).to.equal(1)
-          expectSet(psC.topics.get(topic), [psB.peerId.toString()])
+          expect(psC.getPeers().length).to.equal(1)
+          expect(psC.getSubscribers(topic).map(p => p.toString())).to.deep.equal([peerIdB.toString()])
         })
 
         it('subscribe to the topic on node c', async () => {
@@ -98,12 +143,12 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
           const defer = pDefer()
 
           psC.subscribe(topic)
-          expectSet(psC.subscriptions, [topic])
+          expect(psC.getTopics()).to.deep.equal([topic])
 
           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()])
+            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()])
 
             defer.resolve()
           }, {
@@ -117,25 +162,24 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
           const topic = 'Z'
           const defer = pDefer()
 
-          psA.subscribe(topic)
-          psB.subscribe(topic)
-          psC.subscribe(topic)
-
           // await subscription change
-          await Promise.all([
-            new Promise(resolve => psA.addEventListener('pubsub:subscription-change', () => resolve(null), {
+          const p = Promise.all([
+            new Promise<void>(resolve => psA.addEventListener('pubsub:subscription-change', () => resolve(), {
               once: true
             })),
-            new Promise(resolve => psB.addEventListener('pubsub:subscription-change', () => resolve(null), {
+            new Promise<void>(resolve => psB.addEventListener('pubsub:subscription-change', () => resolve(), {
               once: true
             })),
-            new Promise(resolve => psC.addEventListener('pubsub:subscription-change', () => resolve(null), {
+            new Promise<void>(resolve => psC.addEventListener('pubsub:subscription-change', () => resolve(), {
               once: true
             }))
           ])
 
-          // await a cycle
-          await delay(1000)
+          psA.subscribe(topic)
+          psB.subscribe(topic)
+          psC.subscribe(topic)
+
+          await p
 
           let counter = 0
 
@@ -143,7 +187,10 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
           psB.addEventListener(topic, incMsg)
           psC.addEventListener(topic, incMsg)
 
-          void psA.publish(topic, uint8ArrayFromString('hey'))
+          // await a cycle
+          await delay(1000)
+
+          void psA.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('hey') }))
 
           function incMsg (evt: CustomEvent<Message>) {
             const msg = evt.detail
@@ -201,7 +248,7 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
             // await a cycle
             await delay(1000)
 
-            void psB.publish(topic, uint8ArrayFromString('hey'))
+            void psB.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('hey') }))
 
             function incMsg (evt: CustomEvent<Message>) {
               const msg = evt.detail
@@ -231,61 +278,127 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
         //   │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
+        let peerIdD: PeerId
+        let peerIdE: PeerId
+        let registrarA: Registrar
+        let registrarB: Registrar
+        let registrarC: Registrar
+        let registrarD: Registrar
+        let registrarE: Registrar
 
         // Create and start pubsub nodes
         beforeEach(async () => {
-          psA = await common.setup()
-          psB = await common.setup()
-          psC = await common.setup()
-          psD = await common.setup()
-          psE = await common.setup()
+          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()
+
+          psA = await common.setup({
+            peerId: peerIdA,
+            registrar: registrarA,
+            emitSelf: true
+          })
+          psB = await common.setup({
+            peerId: peerIdB,
+            registrar: registrarB,
+            emitSelf: true
+          })
+          psC = await common.setup({
+            peerId: peerIdC,
+            registrar: registrarC,
+            emitSelf: true
+          })
+          psD = await common.setup({
+            peerId: peerIdD,
+            registrar: registrarD,
+            emitSelf: true
+          })
+          psE = await common.setup({
+            peerId: peerIdE,
+            registrar: registrarE,
+            emitSelf: true
+          })
 
           // Start pubsub nodes
-          ;[psA, psB, psC, psD, psE].map((p) => p.start())
+          await Promise.all(
+            [psA, psB, psC, psD, psE].map(async (p) => await p.start())
+          )
         })
 
         // connect nodes
         beforeEach(async () => {
-          // @ts-expect-error protected field
-          await psA._libp2p.dial(psB.peerId)
-          // @ts-expect-error protected field
-          await psB._libp2p.dial(psC.peerId)
-          // @ts-expect-error protected field
-          await psC._libp2p.dial(psD.peerId)
-          // @ts-expect-error protected field
-          await psD._libp2p.dial(psE.peerId)
+          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(() =>
-            psA.peers.size === 1 &&
-            psB.peers.size === 2 &&
-            psC.peers.size === 2 &&
-            psD.peers.size === 2 &&
-            psE.peers.size === 1
+            psA.getPeers().length === 1 &&
+            psB.getPeers().length === 2 &&
+            psC.getPeers().length === 2 &&
+            psD.getPeers().length === 2 &&
+            psE.getPeers().length === 1
           )
         })
 
         afterEach(async () => {
-          [psA, psB, psC, psD, psE].map((p) => p.stop())
+          await Promise.all(
+            [psA, psB, psC, psD, psE].map(async (p) => await p.stop())
+          )
           await common.teardown()
         })
 
         it('subscribes', () => {
           psA.subscribe('Z')
-          expectSet(psA.subscriptions, ['Z'])
+          expect(psA.getTopics()).to.deep.equal(['Z'])
           psB.subscribe('Z')
-          expectSet(psB.subscriptions, ['Z'])
+          expect(psB.getTopics()).to.deep.equal(['Z'])
           psC.subscribe('Z')
-          expectSet(psC.subscriptions, ['Z'])
+          expect(psC.getTopics()).to.deep.equal(['Z'])
           psD.subscribe('Z')
-          expectSet(psD.subscriptions, ['Z'])
+          expect(psD.getTopics()).to.deep.equal(['Z'])
           psE.subscribe('Z')
-          expectSet(psE.subscriptions, ['Z'])
+          expect(psE.getTopics()).to.deep.equal(['Z'])
         })
 
         it('publishes from c', async function () {
@@ -314,7 +427,7 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
           // 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