@libp2p/interface-compliance-tests 1.1.24 → 1.1.27

package/src/pubsub/connection-handlers.ts

@@ -4,46 +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, 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 { 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<PubSub, PubSubArgs>) => {
   describe('pubsub connection handlers', () => {
     let psA: PubSub
     let psB: PubSub
-    let peerA: PeerId
-    let peerB: PeerId
-    let registrarA: Registrar
-    let registrarB: Registrar
+    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: {}
         })
 
@@ -55,7 +43,7 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
       })
 
       // Make subscriptions prior to nodes connected
-      before(() => {
+      beforeEach(() => {
         psA.subscribe('Za')
         psB.subscribe('Zb')
 
@@ -65,28 +53,19 @@ export default (common: TestSetup<PubSub, 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
 
@@ -96,39 +75,28 @@ export default (common: TestSetup<PubSub, 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: PubSub
       let psB: PubSub
-      let peerA: PeerId
-      let peerB: PeerId
-      let registrarA: Registrar
-      let registrarB: Registrar
+      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: {}
         })
 
@@ -137,18 +105,12 @@ export default (common: TestSetup<PubSub, 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),
@@ -161,13 +123,7 @@ export default (common: TestSetup<PubSub, 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)
@@ -188,9 +144,9 @@ export default (common: TestSetup<PubSub, 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
       })
@@ -199,53 +155,34 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
     describe('pubsub started after connect', () => {
       let psA: PubSub
       let psB: PubSub
-      let peerA: PeerId
-      let peerB: PeerId
-      let registrarA: Registrar
-      let registrarB: Registrar
+      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),
@@ -260,13 +197,7 @@ export default (common: TestSetup<PubSub, 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),
@@ -292,9 +223,9 @@ export default (common: TestSetup<PubSub, 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
       })
@@ -303,31 +234,20 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
     describe('pubsub with intermittent connections', () => {
       let psA: PubSub
       let psB: PubSub
-      let peerA: PeerId
-      let peerB: PeerId
-      let registrarA: Registrar
-      let registrarB: Registrar
+      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: {}
         })
 
@@ -336,9 +256,7 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
 
       afterEach(async () => {
         sinon.restore()
-
         await stop(psA, psB)
-
         await common.teardown()
       })
 
@@ -350,13 +268,7 @@ export default (common: TestSetup<PubSub, 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)
@@ -378,9 +290,9 @@ export default (common: TestSetup<PubSub, 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
 
@@ -399,21 +311,15 @@ export default (common: TestSetup<PubSub, 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
       })
@@ -469,23 +375,17 @@ export default (common: TestSetup<PubSub, 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
         })
@@ -498,8 +398,8 @@ export default (common: TestSetup<PubSub, 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

@@ -8,6 +8,7 @@ import type { PubSubArgs } from './index.js'
 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')
@@ -16,14 +17,14 @@ const shouldNotHappen = () => expect.fail()
 export default (common: TestSetup<PubSub, PubSubArgs>) => {
   describe('emit self', () => {
     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<PubSub, 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<PubSub, 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/messages.ts

@@ -1,33 +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 { mockRegistrar } from '../mocks/registrar.js'
 import type { TestSetup } from '../index.js'
 import type { Message, PubSub } from '@libp2p/interfaces/pubsub'
 import type { PubSubArgs } from './index.js'
-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<PubSub, PubSubArgs>) => {
   describe('messages', () => {
-    let peerId: PeerId
     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
         }
@@ -42,13 +37,16 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
     })
 
     it('should emit normalized signed messages on publish', async () => {
+      const eventPromise = pEvent<'message', CustomEvent<Message>>(pubsub, 'message')
+
       pubsub.globalSignaturePolicy = 'StrictSign'
-      pubsub.publish(topic, data)
+      pubsub.subscribe(topic)
+      await pubsub.publish(topic, data)
 
-      const event = await pEvent<'message', CustomEvent<Message>>(pubsub, 'message')
+      const event = await eventPromise
       const message = event.detail
 
-      expect(message.from.toString()).to.equal(peerId.toString())
+      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)