@libp2p/interface-compliance-tests 1.1.21 → 1.1.24

package/src/pubsub/api.ts

@@ -6,18 +6,16 @@ import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { mockRegistrar } from '../mocks/registrar.js'
 import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 import delay from 'delay'
-import { CustomEvent } from '@libp2p/interfaces'
 import type { TestSetup } from '../index.js'
 import type { PubSub } from '@libp2p/interfaces/pubsub'
 import type { PubSubArgs } from './index.js'
 import type { Registrar } from '@libp2p/interfaces/registrar'
-import type { PubSubBaseProtocol } from '@libp2p/pubsub'
 import { Components } from '@libp2p/interfaces/components'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
 
-export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
+export default (common: TestSetup<PubSub, PubSubArgs>) => {
   describe('pubsub api', () => {
     let pubsub: PubSub
     let registrar: Registrar
@@ -68,19 +66,21 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
       }
 
       await pubsub.start()
-      pubsub.addEventListener(topic, handler)
+      pubsub.subscribe(topic)
+      pubsub.addEventListener('message', handler)
 
       await pWaitFor(() => {
         const topics = pubsub.getTopics()
         return topics.length === 1 && topics[0] === topic
       })
 
-      pubsub.removeEventListener(topic, handler)
+      pubsub.removeEventListener('message', handler)
+      pubsub.unsubscribe(topic)
 
       await pWaitFor(() => pubsub.getTopics().length === 0)
 
       // Publish to guarantee the handler is not called
-      pubsub.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
+      pubsub.publish(topic, data)
 
       // handlers are called async
       await delay(100)
@@ -93,12 +93,13 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
 
       await pubsub.start()
 
-      pubsub.addEventListener(topic, (evt) => {
-        const msg = evt.detail
-        expect(msg).to.not.eql(undefined)
+      pubsub.subscribe(topic)
+      pubsub.addEventListener('message', (evt) => {
+        expect(evt).to.have.nested.property('detail.topic', topic)
+        expect(evt).to.have.deep.nested.property('detail.data', data)
         defer.resolve()
       })
-      pubsub.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
+      pubsub.publish(topic, data)
       await defer.promise
 
       await pubsub.stop()

package/src/pubsub/connection-handlers.ts

@@ -6,20 +6,18 @@ 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 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 { start, stop } from '../index.js'
 
-export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
+export default (common: TestSetup<PubSub, PubSubArgs>) => {
   describe('pubsub connection handlers', () => {
-    let psA: PubSubBaseProtocol
-    let psB: PubSubBaseProtocol
+    let psA: PubSub
+    let psB: PubSub
     let peerA: PeerId
     let peerB: PeerId
     let registrarA: Registrar
@@ -74,10 +72,10 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
 
       it('existing subscriptions are sent upon peer connection', async function () {
         const subscriptionsChanged = Promise.all([
-          new Promise((resolve) => psA.addEventListener('pubsub:subscription-change', resolve, {
+          new Promise((resolve) => psA.addEventListener('subscription-change', resolve, {
             once: true
           })),
-          new Promise((resolve) => psB.addEventListener('pubsub:subscription-change', resolve, {
+          new Promise((resolve) => psB.addEventListener('subscription-change', resolve, {
             once: true
           }))
         ])
@@ -104,8 +102,8 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
     })
 
     describe('pubsub started before connect', () => {
-      let psA: PubSubBaseProtocol
-      let psB: PubSubBaseProtocol
+      let psA: PubSub
+      let psB: PubSub
       let peerA: PeerId
       let peerB: PeerId
       let registrarA: Registrar
@@ -174,10 +172,13 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         let subscribedTopics = psA.getTopics()
         expect(subscribedTopics).to.not.include(topic)
 
-        psA.addEventListener(topic, (evt) => {
-          const msg = evt.detail
-          expect(msg.data).to.equalBytes(data)
-          defer.resolve()
+        psA.subscribe(topic)
+        psA.addEventListener('message', (evt) => {
+          if (evt.detail.topic === topic) {
+            const msg = evt.detail
+            expect(msg.data).to.equalBytes(data)
+            defer.resolve()
+          }
         })
         psA.subscribe(topic)
 
@@ -189,15 +190,15 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
           const subscribedPeers = psB.getSubscribers(topic)
           return subscribedPeers.map(p => p.toString()).includes(peerA.toString())
         })
-        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
+        psB.publish(topic, data)
 
         await defer.promise
       })
     })
 
     describe('pubsub started after connect', () => {
-      let psA: PubSubBaseProtocol
-      let psB: PubSubBaseProtocol
+      let psA: PubSub
+      let psB: PubSub
       let peerA: PeerId
       let peerB: PeerId
       let registrarA: Registrar
@@ -275,10 +276,13 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         let subscribedTopics = psA.getTopics()
         expect(subscribedTopics).to.not.include(topic)
 
-        psA.addEventListener(topic, (evt) => {
-          const msg = evt.detail
-          expect(msg.data).to.equalBytes(data)
-          defer.resolve()
+        psA.subscribe(topic)
+        psA.addEventListener('message', (evt) => {
+          if (evt.detail.topic === topic) {
+            const msg = evt.detail
+            expect(msg.data).to.equalBytes(data)
+            defer.resolve()
+          }
         })
         psA.subscribe(topic)
 
@@ -290,15 +294,15 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
           const subscribedPeers = psB.getSubscribers(topic)
           return subscribedPeers.map(p => p.toString()).includes(peerA.toString())
         })
-        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
+        psB.publish(topic, data)
 
         await defer.promise
       })
     })
 
     describe('pubsub with intermittent connections', () => {
-      let psA: PubSubBaseProtocol
-      let psB: PubSubBaseProtocol
+      let psA: PubSub
+      let psB: PubSub
       let peerA: PeerId
       let peerB: PeerId
       let registrarA: Registrar
@@ -357,11 +361,14 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         let subscribedTopics = psA.getTopics()
         expect(subscribedTopics).to.not.include(topic)
 
-        psA.addEventListener(topic, (evt) => {
-          const msg = evt.detail
-          expect(msg.data).to.equalBytes(data)
-          counter++
-          counter === 1 ? defer1.resolve() : defer2.resolve()
+        psA.subscribe(topic)
+        psA.addEventListener('message', (evt) => {
+          if (evt.detail.topic === topic) {
+            const msg = evt.detail
+            expect(msg.data).to.equalBytes(data)
+            counter++
+            counter === 1 ? defer1.resolve() : defer2.resolve()
+          }
         })
         psA.subscribe(topic)
 
@@ -373,7 +380,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
           const subscribedPeers = psB.getSubscribers(topic)
           return subscribedPeers.map(p => p.toString()).includes(peerA.toString())
         })
-        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
+        psB.publish(topic, data)
 
         await defer1.promise
 
@@ -406,7 +413,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
           return subscribedPeers.toString().includes(peerA.toString())
         })
 
-        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
+        psB.publish(topic, data)
 
         await defer2.promise
       })
@@ -417,8 +424,13 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         let aReceivedSecondMessageFromB = false
         let bReceivedFirstMessageFromA = false
         let bReceivedSecondMessageFromA = false
+        const topic = 'reconnect-channel'
 
         const handlerSpyA = (evt: CustomEvent<Message>) => {
+          if (evt.detail.topic !== topic) {
+            return
+          }
+
           const message = evt.detail
           const data = uint8ArrayToString(message.data)
 
@@ -431,6 +443,10 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
           }
         }
         const handlerSpyB = (evt: CustomEvent<Message>) => {
+          if (evt.detail.topic !== topic) {
+            return
+          }
+
           const message = evt.detail
           const data = uint8ArrayToString(message.data)
 
@@ -443,10 +459,8 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
           }
         }
 
-        const topic = 'reconnect-channel'
-
-        psA.addEventListener(topic, handlerSpyA)
-        psB.addEventListener(topic, handlerSpyB)
+        psA.addEventListener('message', handlerSpyA)
+        psB.addEventListener('message', handlerSpyB)
         psA.subscribe(topic)
         psB.subscribe(topic)
 
@@ -470,8 +484,8 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         })
 
         // Verify messages go both ways
-        void psA.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('message-from-a-1') }))
-        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('message-from-b-1') }))
+        psA.publish(topic, uint8ArrayFromString('message-from-a-1'))
+        psB.publish(topic, uint8ArrayFromString('message-from-b-1'))
         await pWaitFor(() => {
           return aReceivedFirstMessageFromB && bReceivedFirstMessageFromA
         })
@@ -484,8 +498,8 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         await pWaitFor(() => psAConnUpdateSpy.callCount === 1)
 
         // Verify messages go both ways after the disconnect
-        void psA.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('message-from-a-2') }))
-        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('message-from-b-2') }))
+        psA.publish(topic, uint8ArrayFromString('message-from-a-2'))
+        psB.publish(topic, uint8ArrayFromString('message-from-b-2'))
         await pWaitFor(() => {
           return aReceivedSecondMessageFromB && bReceivedSecondMessageFromA
         })

package/src/pubsub/emit-self.ts

@@ -3,20 +3,19 @@ import sinon from 'sinon'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 import { mockRegistrar } from '../mocks/registrar.js'
-import { CustomEvent } from '@libp2p/interfaces'
 import type { TestSetup } from '../index.js'
 import type { PubSubArgs } from './index.js'
-import type { PubSubBaseProtocol } from '@libp2p/pubsub'
 import { Components } from '@libp2p/interfaces/components'
 import { start, stop } from '../index.js'
+import type { PubSub } from '@libp2p/interfaces/pubsub'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
 const shouldNotHappen = () => expect.fail()
 
-export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
+export default (common: TestSetup<PubSub, PubSubArgs>) => {
   describe('emit self', () => {
-    let pubsub: PubSubBaseProtocol
+    let pubsub: PubSub
 
     describe('enabled', () => {
       before(async () => {
@@ -43,11 +42,17 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
       })
 
       it('should emit to self on publish', async () => {
-        const promise = new Promise((resolve) => pubsub.addEventListener(topic, resolve, {
-          once: true
-        }))
+        const promise = new Promise<void>((resolve) => {
+          pubsub.addEventListener('message', (evt) => {
+            if (evt.detail.topic === topic) {
+              resolve()
+            }
+          }, {
+            once: true
+          })
+        })
 
-        void pubsub.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
+        pubsub.publish(topic, data)
 
         return await promise
       })
@@ -78,11 +83,11 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
       })
 
       it('should not emit to self on publish', async () => {
-        pubsub.addEventListener(topic, () => shouldNotHappen, {
+        pubsub.addEventListener('message', shouldNotHappen, {
           once: true
         })
 
-        void pubsub.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
+        pubsub.publish(topic, data)
 
         // Wait 1 second to guarantee that self is not noticed
         return await new Promise((resolve) => setTimeout(resolve, 1000))

package/src/pubsub/index.ts

@@ -5,8 +5,7 @@ import connectionHandlersTest from './connection-handlers.js'
 import twoNodesTest from './two-nodes.js'
 import multipleNodesTest from './multiple-nodes.js'
 import type { TestSetup } from '../index.js'
-import type { PubSubInit } from '@libp2p/interfaces/pubsub'
-import type { PubSubBaseProtocol } from '@libp2p/pubsub'
+import type { PubSub, PubSubInit } from '@libp2p/interfaces/pubsub'
 import type { Components } from '@libp2p/interfaces/components'
 
 export interface PubSubArgs {
@@ -14,7 +13,7 @@ export interface PubSubArgs {
   init: PubSubInit
 }
 
-export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
+export default (common: TestSetup<PubSub, PubSubArgs>) => {
   describe('interface-pubsub compliance tests', () => {
     apiTest(common)
     emitSelfTest(common)

package/src/pubsub/messages.ts

@@ -2,28 +2,22 @@ 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 { start, stop } from '../index.js'
+import { pEvent } from 'p-event'
 
 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
 
     // Create pubsub router
     beforeEach(async () => {
@@ -49,88 +43,15 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
 
     it('should emit normalized signed messages on publish', async () => {
       pubsub.globalSignaturePolicy = 'StrictSign'
+      pubsub.publish(topic, data)
 
-      const spy = sinon.spy(pubsub, 'publishMessage')
+      const event = await pEvent<'message', CustomEvent<Message>>(pubsub, 'message')
+      const message = event.detail
 
-      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
-        }]
-      }
-
-      pubsub.subscribe(topic)
-
-      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)
-      expect(publishSpy).to.have.property('callCount', 1)
+      expect(message.from.toString()).to.equal(peerId.toString())
+      expect(message.sequenceNumber).to.not.eql(undefined)
+      expect(message.key).to.not.eql(undefined)
+      expect(message.signature).to.not.eql(undefined)
     })
   })
 }