@libp2p/interface-compliance-tests 1.1.22 → 1.1.25

package/src/pubsub/messages.ts

@@ -1,39 +1,28 @@
 import { expect } from 'aegir/chai'
 import sinon from 'sinon'
-import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-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 { PubSubRPC } from '@libp2p/interfaces/pubsub'
+import type { Message, PubSub } from '@libp2p/interfaces/pubsub'
 import type { PubSubArgs } from './index.js'
-import type { PubSubBaseProtocol } from '@libp2p/pubsub'
-import { Components } from '@libp2p/interfaces/components'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { Components } from '@libp2p/interfaces/components'
 import { start, stop } from '../index.js'
+import { pEvent } from 'p-event'
+import { createComponents } from './utils.js'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
 
-export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
+export default (common: TestSetup<PubSub, PubSubArgs>) => {
   describe('messages', () => {
-    let peerId: PeerId
-    let pubsub: PubSubBaseProtocol
+    let pubsub: PubSub
+    let components: Components
 
     // Create pubsub router
     beforeEach(async () => {
-      peerId = await createEd25519PeerId()
+      components = await createComponents()
 
       pubsub = await common.setup({
-        components: new Components({
-          peerId,
-          registrar: mockRegistrar()
-        }),
+        components,
         init: {
           emitSelf: true
         }
@@ -48,89 +37,19 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
     })
 
     it('should emit normalized signed messages on publish', async () => {
-      pubsub.globalSignaturePolicy = 'StrictSign'
-
-      const spy = sinon.spy(pubsub, 'publishMessage')
-
-      await pubsub.dispatchEvent(new CustomEvent<Uint8Array>(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(peerId.toString())
-      expect(messageToEmit.sequenceNumber).to.not.eql(undefined)
-      expect(messageToEmit.key).to.not.eql(undefined)
-      expect(messageToEmit.signature).to.not.eql(undefined)
-    })
-
-    it('should drop unsigned messages', async () => {
-      const publishSpy = sinon.spy(pubsub, 'publishMessage')
-      sinon.spy(pubsub, 'validate')
-
-      const peerStream = new PeerStreams({
-        id: await createEd25519PeerId(),
-        protocol: 'test'
-      })
-      const rpc: PubSubRPC = {
-        subscriptions: [],
-        messages: [{
-          from: peerStream.id.toBytes(),
-          data,
-          sequenceNumber: await noSignMsgId(data),
-          topic: topic
-        }]
-      }
-
-      pubsub.subscribe(topic)
-
-      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'
-
-      const publishSpy = sinon.spy(pubsub, 'publishMessage')
-      sinon.spy(pubsub, 'validate')
-
-      const peerStream = new PeerStreams({
-        id: await createEd25519PeerId(),
-        protocol: 'test'
-      })
-
-      const rpc: PubSubRPC = {
-        subscriptions: [],
-        messages: [{
-          from: peerStream.id.toBytes(),
-          data,
-          topic
-        }]
-      }
+      const eventPromise = pEvent<'message', CustomEvent<Message>>(pubsub, 'message')
 
+      pubsub.globalSignaturePolicy = 'StrictSign'
       pubsub.subscribe(topic)
+      await pubsub.publish(topic, data)
 
-      const deferred = pDefer()
-
-      pubsub.addEventListener(topic, () => {
-        deferred.resolve()
-      })
-
-      await pubsub.processRpc(peerStream.id, peerStream, rpc)
-
-      // await message delivery
-      await deferred.promise
+      const event = await eventPromise
+      const message = event.detail
 
-      expect(pubsub.validate).to.have.property('callCount', 1)
-      expect(publishSpy).to.have.property('callCount', 1)
+      expect(message.from.toString()).to.equal(components.getPeerId().toString())
+      expect(message.sequenceNumber).to.not.eql(undefined)
+      expect(message.key).to.not.eql(undefined)
+      expect(message.signature).to.not.eql(undefined)
     })
   })
 }

package/src/pubsub/multiple-nodes.ts

@@ -5,69 +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 { CustomEvent } from '@libp2p/interfaces'
-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
             }
@@ -79,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(() =>
@@ -116,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()
@@ -131,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 () => {
@@ -149,10 +116,10 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
           psC.subscribe(topic)
           expect(psC.getTopics()).to.deep.equal([topic])
 
-          psB.addEventListener('pubsub:subscription-change', () => {
+          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()
           }, {
@@ -172,29 +139,36 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
 
           let counter = 0
 
-          psA.addEventListener(topic, incMsg)
-          psB.addEventListener(topic, incMsg)
-          psC.addEventListener(topic, incMsg)
+          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())
           ])
 
-          void psA.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: 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(topic, incMsg)
-              psB.removeEventListener(topic, incMsg)
-              psC.removeEventListener(topic, incMsg)
+              psA.removeEventListener('message', incMsg)
+              psB.removeEventListener('message', incMsg)
+              psC.removeEventListener('message', incMsg)
               defer.resolve()
             }
           }
@@ -216,46 +190,38 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
             const defer = pDefer()
             let counter = 0
 
+            psA.addEventListener('message', incMsg)
+            psB.addEventListener('message', incMsg)
+            psC.addEventListener('message', incMsg)
+
             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), {
-                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
-              }))
+              waitForSubscriptionUpdate(psA, componentsB.getPeerId()),
+              waitForSubscriptionUpdate(psB, componentsA.getPeerId()),
+              waitForSubscriptionUpdate(psC, componentsB.getPeerId())
             ])
 
-            psA.addEventListener(topic, incMsg)
-            psB.addEventListener(topic, incMsg)
-            psC.addEventListener(topic, incMsg)
-
-            await Promise.all([
-              waitForSubscriptionUpdate(psA, psB),
-              waitForSubscriptionUpdate(psB, psA),
-              waitForSubscriptionUpdate(psC, psB)
-            ])
-
-            void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: 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(topic, incMsg)
-                psB.removeEventListener(topic, incMsg)
-                psC.removeEventListener(topic, incMsg)
+                psA.removeEventListener('message', incMsg)
+                psB.removeEventListener('message', incMsg)
+                psC.removeEventListener('message', incMsg)
                 defer.resolve()
               }
             }
@@ -273,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
             }
@@ -355,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(() =>
@@ -415,30 +331,36 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         it('publishes from c', async function () {
           const defer = pDefer()
           let counter = 0
+          const topic = 'Z'
 
-          psA.subscribe('Z')
-          psA.addEventListener('Z', incMsg)
-          psB.subscribe('Z')
-          psB.addEventListener('Z', incMsg)
-          psC.subscribe('Z')
-          psC.addEventListener('Z', incMsg)
-          psD.subscribe('Z')
-          psD.addEventListener('Z', incMsg)
-          psE.subscribe('Z')
-          psE.addEventListener('Z', incMsg)
+          psA.subscribe(topic)
+          psA.addEventListener('message', incMsg)
+          psB.subscribe(topic)
+          psB.addEventListener('message', incMsg)
+          psC.subscribe(topic)
+          psC.addEventListener('message', incMsg)
+          psD.subscribe(topic)
+          psD.addEventListener('message', incMsg)
+          psE.subscribe(topic)
+          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())
           ])
 
-          void psC.dispatchEvent(new CustomEvent<Uint8Array>('Z', { detail: 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()
           }