@libp2p/interface-compliance-tests 1.1.22 → 1.1.25

package/src/pubsub/connection-handlers.ts

@@ -4,48 +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 { CustomEvent } from '@libp2p/interfaces'
+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()
+        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: {}
         })
 
@@ -74,21 +60,11 @@ 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, {
-            once: true
-          })),
-          new Promise((resolve) => psB.addEventListener('pubsub: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
 
@@ -98,39 +74,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: {}
         })
 
@@ -144,13 +109,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
       })
 
       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),
@@ -163,21 +122,18 @@ 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)
 
-        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)
 
@@ -187,42 +143,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
         })
-        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: 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: {}
         })
       })
@@ -238,13 +183,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
       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),
@@ -259,13 +198,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),
@@ -275,10 +208,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)
 
@@ -288,42 +224,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
         })
-        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: 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: {}
         })
 
@@ -346,22 +271,19 @@ 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)
 
-        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)
 
@@ -371,9 +293,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
         })
-        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
+        await psB.publish(topic, data)
 
         await defer1.promise
 
@@ -392,21 +314,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())
         })
 
-        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
+        await psB.publish(topic, data)
 
         await defer2.promise
       })
@@ -417,8 +333,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 +352,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 +368,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)
 
@@ -455,23 +378,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
-        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') }))
+        await psA.publish(topic, uint8ArrayFromString('message-from-a-1'))
+        await psB.publish(topic, uint8ArrayFromString('message-from-b-1'))
         await pWaitFor(() => {
           return aReceivedFirstMessageFromB && bReceivedFirstMessageFromA
         })
@@ -484,8 +401,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') }))
+        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

@@ -3,28 +3,28 @@ 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'
+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
           }
@@ -43,13 +43,21 @@ 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
+          })
+        })
+
+        const result = await pubsub.publish(topic, data)
 
-        void pubsub.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
+        await promise
 
-        return await promise
+        expect(result).to.have.property('recipients').with.lengthOf(1)
       })
     })
 
@@ -78,11 +86,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 }))
+        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)