@libp2p/interface-compliance-tests 1.1.23 → 1.1.26

package/src/pubsub/connection-handlers.ts

@@ -4,47 +4,34 @@ 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 { connectPeers } from '../mocks/registrar.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'
+import { createComponents } from './utils.js'
+import { pEvent } from 'p-event'
 
-export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
+export default (common: TestSetup<PubSub, PubSubArgs>) => {
   describe('pubsub connection handlers', () => {
-    let psA: PubSubBaseProtocol
-    let psB: PubSubBaseProtocol
-    let peerA: PeerId
-    let peerB: PeerId
-    let registrarA: Registrar
-    let registrarB: Registrar
+    let psA: PubSub
+    let psB: PubSub
+    let componentsA: Components
+    let componentsB: Components
 
     describe('nodes send state on connection', () => {
       // Create pubsub nodes and connect them
-      before(async () => {
-        peerA = await createEd25519PeerId()
-        peerB = await createEd25519PeerId()
-
-        registrarA = mockRegistrar()
-        registrarB = mockRegistrar()
+      beforeEach(async () => {
+        componentsA = await createComponents()
+        componentsB = await createComponents()
 
         psA = await common.setup({
-          components: new Components({
-            peerId: peerA,
-            registrar: registrarA
-          }),
+          components: componentsA,
           init: {}
         })
         psB = await common.setup({
-          components: new Components({
-            peerId: peerB,
-            registrar: registrarB
-          }),
+          components: componentsB,
           init: {}
         })
 
@@ -56,7 +43,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
       })
 
       // Make subscriptions prior to nodes connected
-      before(() => {
+      beforeEach(() => {
         psA.subscribe('Za')
         psB.subscribe('Zb')
 
@@ -66,28 +53,19 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         expect(psB.getTopics()).to.deep.equal(['Zb'])
       })
 
-      after(async () => {
+      afterEach(async () => {
         sinon.restore()
+        await stop(psA, psB)
         await common.teardown()
       })
 
       it('existing subscriptions are sent upon peer connection', async function () {
         const subscriptionsChanged = Promise.all([
-          new Promise((resolve) => psA.addEventListener('subscription-change', resolve, {
-            once: true
-          })),
-          new Promise((resolve) => psB.addEventListener('subscription-change', resolve, {
-            once: true
-          }))
+          pEvent(psA, 'subscription-change'),
+          pEvent(psB, 'subscription-change')
         ])
 
-        await connectPeers(psA.multicodecs[0], {
-          peerId: peerA,
-          registrar: registrarA
-        }, {
-          peerId: peerB,
-          registrar: registrarB
-        })
+        await connectPeers(psA.multicodecs[0], componentsA, componentsB)
 
         await subscriptionsChanged
 
@@ -97,39 +75,28 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         expect(psA.getTopics()).to.deep.equal(['Za'])
         expect(psB.getTopics()).to.deep.equal(['Zb'])
 
-        expect(psA.getSubscribers('Zb').map(p => p.toString())).to.deep.equal([peerB.toString()])
-        expect(psB.getSubscribers('Za').map(p => p.toString())).to.deep.equal([peerA.toString()])
+        expect(psA.getSubscribers('Zb').map(p => p.toString())).to.deep.equal([componentsB.getPeerId().toString()])
+        expect(psB.getSubscribers('Za').map(p => p.toString())).to.deep.equal([componentsA.getPeerId().toString()])
       })
     })
 
     describe('pubsub started before connect', () => {
-      let psA: PubSubBaseProtocol
-      let psB: PubSubBaseProtocol
-      let peerA: PeerId
-      let peerB: PeerId
-      let registrarA: Registrar
-      let registrarB: Registrar
+      let psA: PubSub
+      let psB: PubSub
+      let componentsA: Components
+      let componentsB: Components
 
       // Create pubsub nodes and start them
       beforeEach(async () => {
-        peerA = await createEd25519PeerId()
-        peerB = await createEd25519PeerId()
-
-        registrarA = mockRegistrar()
-        registrarB = mockRegistrar()
+        componentsA = await createComponents()
+        componentsB = await createComponents()
 
         psA = await common.setup({
-          components: new Components({
-            peerId: peerA,
-            registrar: registrarA
-          }),
+          components: componentsA,
           init: {}
         })
         psB = await common.setup({
-          components: new Components({
-            peerId: peerB,
-            registrar: registrarB
-          }),
+          components: componentsB,
           init: {}
         })
 
@@ -138,18 +105,12 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
 
       afterEach(async () => {
         sinon.restore()
-
+        await stop(psA, psB)
         await common.teardown()
       })
 
       it('should get notified of connected peers on dial', async () => {
-        await connectPeers(psA.multicodecs[0], {
-          peerId: peerA,
-          registrar: registrarA
-        }, {
-          peerId: peerB,
-          registrar: registrarB
-        })
+        await connectPeers(psA.multicodecs[0], componentsA, componentsB)
 
         return await Promise.all([
           pWaitFor(() => psA.getPeers().length === 1),
@@ -162,13 +123,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         const topic = 'test-topic'
         const data = uint8ArrayFromString('hey!')
 
-        await connectPeers(psA.multicodecs[0], {
-          peerId: peerA,
-          registrar: registrarA
-        }, {
-          peerId: peerB,
-          registrar: registrarB
-        })
+        await connectPeers(psA.multicodecs[0], componentsA, componentsB)
 
         let subscribedTopics = psA.getTopics()
         expect(subscribedTopics).to.not.include(topic)
@@ -189,64 +144,45 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         // wait for psB to know about psA subscription
         await pWaitFor(() => {
           const subscribedPeers = psB.getSubscribers(topic)
-          return subscribedPeers.map(p => p.toString()).includes(peerA.toString())
+          return subscribedPeers.map(p => p.toString()).includes(componentsA.getPeerId().toString()) // eslint-disable-line max-nested-callbacks
         })
-        psB.publish(topic, data)
+        await psB.publish(topic, data)
 
         await defer.promise
       })
     })
 
     describe('pubsub started after connect', () => {
-      let psA: PubSubBaseProtocol
-      let psB: PubSubBaseProtocol
-      let peerA: PeerId
-      let peerB: PeerId
-      let registrarA: Registrar
-      let registrarB: Registrar
+      let psA: PubSub
+      let psB: PubSub
+      let componentsA: Components
+      let componentsB: Components
 
       // Create pubsub nodes
       beforeEach(async () => {
-        peerA = await createEd25519PeerId()
-        peerB = await createEd25519PeerId()
-
-        registrarA = mockRegistrar()
-        registrarB = mockRegistrar()
+        componentsA = await createComponents()
+        componentsB = await createComponents()
 
         psA = await common.setup({
-          components: new Components({
-            peerId: peerA,
-            registrar: registrarA
-          }),
+          components: componentsA,
           init: {}
         })
         psB = await common.setup({
-          components: new Components({
-            peerId: peerB,
-            registrar: registrarB
-          }),
+          components: componentsB,
           init: {}
         })
       })
 
       afterEach(async () => {
         sinon.restore()
-
         await stop(psA, psB)
-
         await common.teardown()
       })
 
       it('should get notified of connected peers after starting', async () => {
         await start(psA, psB)
 
-        await connectPeers(psA.multicodecs[0], {
-          peerId: peerA,
-          registrar: registrarA
-        }, {
-          peerId: peerB,
-          registrar: registrarB
-        })
+        await connectPeers(psA.multicodecs[0], componentsA, componentsB)
 
         return await Promise.all([
           pWaitFor(() => psA.getPeers().length === 1),
@@ -261,13 +197,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
 
         await start(psA, psB)
 
-        await connectPeers(psA.multicodecs[0], {
-          peerId: peerA,
-          registrar: registrarA
-        }, {
-          peerId: peerB,
-          registrar: registrarB
-        })
+        await connectPeers(psA.multicodecs[0], componentsA, componentsB)
 
         await Promise.all([
           pWaitFor(() => psA.getPeers().length === 1),
@@ -293,42 +223,31 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         // wait for psB to know about psA subscription
         await pWaitFor(() => {
           const subscribedPeers = psB.getSubscribers(topic)
-          return subscribedPeers.map(p => p.toString()).includes(peerA.toString())
+          return subscribedPeers.map(p => p.toString()).includes(componentsA.getPeerId().toString()) // eslint-disable-line max-nested-callbacks
         })
-        psB.publish(topic, data)
+        await psB.publish(topic, data)
 
         await defer.promise
       })
     })
 
     describe('pubsub with intermittent connections', () => {
-      let psA: PubSubBaseProtocol
-      let psB: PubSubBaseProtocol
-      let peerA: PeerId
-      let peerB: PeerId
-      let registrarA: Registrar
-      let registrarB: Registrar
+      let psA: PubSub
+      let psB: PubSub
+      let componentsA: Components
+      let componentsB: Components
 
       // Create pubsub nodes and start them
       beforeEach(async () => {
-        peerA = await createEd25519PeerId()
-        peerB = await createEd25519PeerId()
-
-        registrarA = mockRegistrar()
-        registrarB = mockRegistrar()
+        componentsA = await createComponents()
+        componentsB = await createComponents()
 
         psA = await common.setup({
-          components: new Components({
-            peerId: peerA,
-            registrar: registrarA
-          }),
+          components: componentsA,
           init: {}
         })
         psB = await common.setup({
-          components: new Components({
-            peerId: peerB,
-            registrar: registrarB
-          }),
+          components: componentsB,
           init: {}
         })
 
@@ -337,9 +256,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
 
       afterEach(async () => {
         sinon.restore()
-
         await stop(psA, psB)
-
         await common.teardown()
       })
 
@@ -351,13 +268,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         const defer1 = pDefer()
         const defer2 = pDefer()
 
-        await connectPeers(psA.multicodecs[0], {
-          peerId: peerA,
-          registrar: registrarA
-        }, {
-          peerId: peerB,
-          registrar: registrarB
-        })
+        await connectPeers(psA.multicodecs[0], componentsA, componentsB)
 
         let subscribedTopics = psA.getTopics()
         expect(subscribedTopics).to.not.include(topic)
@@ -379,9 +290,9 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         // wait for psB to know about psA subscription
         await pWaitFor(() => {
           const subscribedPeers = psB.getSubscribers(topic)
-          return subscribedPeers.map(p => p.toString()).includes(peerA.toString())
+          return subscribedPeers.map(p => p.toString()).includes(componentsA.getPeerId().toString()) // eslint-disable-line max-nested-callbacks
         })
-        psB.publish(topic, data)
+        await psB.publish(topic, data)
 
         await defer1.promise
 
@@ -400,21 +311,15 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         await psB._libp2p.start()
         await psB.start()
 
-        await connectPeers(psA.multicodecs[0], {
-          peerId: peerA,
-          registrar: registrarA
-        }, {
-          peerId: peerB,
-          registrar: registrarB
-        })
+        await connectPeers(psA.multicodecs[0], componentsA, componentsB)
 
         // wait for remoteLibp2p to know about libp2p subscription
         await pWaitFor(() => {
           const subscribedPeers = psB.getSubscribers(topic)
-          return subscribedPeers.toString().includes(peerA.toString())
+          return subscribedPeers.toString().includes(componentsA.getPeerId().toString())
         })
 
-        psB.publish(topic, data)
+        await psB.publish(topic, data)
 
         await defer2.promise
       })
@@ -470,23 +375,17 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         const originalConnection = await psA._libp2p.dialer.connectToPeer(psB.peerId)
 
         // second connection
-        await connectPeers(psA.multicodecs[0], {
-          peerId: peerA,
-          registrar: registrarA
-        }, {
-          peerId: peerB,
-          registrar: registrarB
-        })
+        await connectPeers(psA.multicodecs[0], componentsA, componentsB)
 
         // Wait for subscriptions to occur
         await pWaitFor(() => {
-          return psA.getSubscribers(topic).includes(peerB) &&
-            psB.getSubscribers(topic).map(p => p.toString()).includes(peerA.toString())
+          return psA.getSubscribers(topic).map(p => p.toString()).includes(componentsB.getPeerId().toString()) &&
+            psB.getSubscribers(topic).map(p => p.toString()).includes(componentsA.getPeerId().toString())
         })
 
         // Verify messages go both ways
-        psA.publish(topic, uint8ArrayFromString('message-from-a-1'))
-        psB.publish(topic, uint8ArrayFromString('message-from-b-1'))
+        await psA.publish(topic, uint8ArrayFromString('message-from-a-1'))
+        await psB.publish(topic, uint8ArrayFromString('message-from-b-1'))
         await pWaitFor(() => {
           return aReceivedFirstMessageFromB && bReceivedFirstMessageFromA
         })
@@ -499,8 +398,8 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         await pWaitFor(() => psAConnUpdateSpy.callCount === 1)
 
         // Verify messages go both ways after the disconnect
-        psA.publish(topic, uint8ArrayFromString('message-from-a-2'))
-        psB.publish(topic, uint8ArrayFromString('message-from-b-2'))
+        await psA.publish(topic, uint8ArrayFromString('message-from-a-2'))
+        await psB.publish(topic, uint8ArrayFromString('message-from-b-2'))
         await pWaitFor(() => {
           return aReceivedSecondMessageFromB && bReceivedSecondMessageFromA
         })

package/src/pubsub/emit-self.ts

@@ -5,25 +5,26 @@ import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 import { mockRegistrar } from '../mocks/registrar.js'
 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'
+import { createComponents } from './utils.js'
 
 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
+    let components: Components
 
     describe('enabled', () => {
       before(async () => {
+        components = await createComponents()
+
         pubsub = await common.setup({
-          components: new Components({
-            peerId: await createEd25519PeerId(),
-            registrar: mockRegistrar()
-          }),
+          components,
           init: {
             emitSelf: true
           }
@@ -52,9 +53,11 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
           })
         })
 
-        pubsub.publish(topic, data)
+        const result = await pubsub.publish(topic, data)
+
+        await promise
 
-        return await promise
+        expect(result).to.have.property('recipients').with.lengthOf(1)
       })
     })
 
@@ -87,7 +90,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
           once: true
         })
 
-        pubsub.publish(topic, data)
+        await 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

@@ -1,38 +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 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
         }
@@ -47,91 +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.publish(topic, 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('message', (evt) => {
-        if (evt.detail.topic === 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)
     })
   })
 }