@libp2p/interface-compliance-tests 1.1.22 → 1.1.25

package/src/pubsub/two-nodes.ts

@@ -5,17 +5,12 @@ 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 { connectPeers, mockRegistrar } from '../mocks/registrar.js'
-import { createEd25519PeerId } from '@libp2p/peer-id-factory'
-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'
 
 const topic = 'foo'
@@ -24,37 +19,26 @@ function shouldNotHappen () {
   expect.fail()
 }
 
-export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
+export default (common: TestSetup<PubSub, PubSubArgs>) => {
   describe('pubsub with two nodes', () => {
-    let psA: PubSubBaseProtocol
-    let psB: PubSubBaseProtocol
-    let peerIdA: PeerId
-    let peerIdB: PeerId
-    let registrarA: Registrar
-    let registrarB: Registrar
+    let psA: PubSub
+    let psB: PubSub
+    let componentsA: Components
+    let componentsB: Components
 
     // Create pubsub nodes and connect them
     beforeEach(async () => {
-      peerIdA = await createEd25519PeerId()
-      peerIdB = await createEd25519PeerId()
-
-      registrarA = mockRegistrar()
-      registrarB = mockRegistrar()
+      componentsA = await createComponents()
+      componentsB = 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: false
         }
@@ -66,13 +50,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
       expect(psA.getPeers()).to.be.empty()
       expect(psB.getPeers()).to.be.empty()
 
-      await connectPeers(psA.multicodecs[0], {
-        peerId: peerIdA,
-        registrar: registrarA
-      }, {
-        peerId: peerIdB,
-        registrar: registrarB
-      })
+      await connectPeers(psA.multicodecs[0], componentsA, componentsB)
 
       // Wait for peers to be ready in pubsub
       await pWaitFor(() => psA.getPeers().length === 1 && psB.getPeers().length === 1)
@@ -89,11 +67,11 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
     it('Subscribe to a topic in nodeA', async () => {
       const defer = pDefer()
 
-      psB.addEventListener('pubsub:subscription-change', (evt) => {
+      psB.addEventListener('subscription-change', (evt) => {
         const { peerId: changedPeerId, subscriptions: changedSubs } = evt.detail
         expect(psA.getTopics()).to.deep.equal([topic])
         expect(psB.getPeers()).to.have.lengthOf(1)
-        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(changedPeerId).to.deep.equal(psB.getPeers()[0])
         expect(changedSubs).to.have.lengthOf(1)
         expect(changedSubs[0].topic).to.equal(topic)
@@ -110,25 +88,26 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
     it('Publish to a topic in nodeA', async () => {
       const defer = pDefer()
 
-      psA.addEventListener(topic, (evt) => {
-        const msg = evt.detail
-        expect(uint8ArrayToString(msg.data)).to.equal('hey')
-        psB.removeEventListener(topic, shouldNotHappen)
-        defer.resolve()
+      psA.addEventListener('message', (evt) => {
+        if (evt.detail.topic === topic) {
+          const msg = evt.detail
+          expect(uint8ArrayToString(msg.data)).to.equal('hey')
+          psB.removeEventListener('message', shouldNotHappen)
+          defer.resolve()
+        }
       }, {
         once: true
       })
 
-      psB.addEventListener(topic, shouldNotHappen, {
-        once: true
-      })
+      psA.subscribe(topic)
+      psB.subscribe(topic)
 
       await Promise.all([
-        waitForSubscriptionUpdate(psA, psB),
-        waitForSubscriptionUpdate(psB, psA)
+        waitForSubscriptionUpdate(psA, componentsB.getPeerId()),
+        waitForSubscriptionUpdate(psB, componentsA.getPeerId())
       ])
 
-      void psA.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('hey') }))
+      await psA.publish(topic, uint8ArrayFromString('hey'))
 
       return await defer.promise
     })
@@ -136,16 +115,24 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
     it('Publish to a topic in nodeB', async () => {
       const defer = pDefer()
 
-      psA.addEventListener(topic, (evt) => {
+      psA.addEventListener('message', (evt) => {
+        if (evt.detail.topic !== topic) {
+          return
+        }
+
         const msg = evt.detail
-        psA.addEventListener(topic, shouldNotHappen, {
+        psA.addEventListener('message', (evt) => {
+          if (evt.detail.topic === topic) {
+            shouldNotHappen()
+          }
+        }, {
           once: true
         })
         expect(uint8ArrayToString(msg.data)).to.equal('banana')
 
         setTimeout(() => {
-          psA.removeEventListener(topic, shouldNotHappen)
-          psB.removeEventListener(topic, shouldNotHappen)
+          psA.removeEventListener('message')
+          psB.removeEventListener('message')
 
           defer.resolve()
         }, 100)
@@ -153,16 +140,17 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         once: true
       })
 
-      psB.addEventListener(topic, shouldNotHappen, {
-        once: true
-      })
+      psB.addEventListener('message', shouldNotHappen)
+
+      psA.subscribe(topic)
+      psB.subscribe(topic)
 
       await Promise.all([
-        waitForSubscriptionUpdate(psA, psB),
-        waitForSubscriptionUpdate(psB, psA)
+        waitForSubscriptionUpdate(psA, componentsB.getPeerId()),
+        waitForSubscriptionUpdate(psB, componentsA.getPeerId())
       ])
 
-      void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('banana') }))
+      await psB.publish(topic, uint8ArrayFromString('banana'))
 
       return await defer.promise
     })
@@ -171,32 +159,35 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
       const defer = pDefer()
       let counter = 0
 
-      psB.addEventListener(topic, shouldNotHappen, {
-        once: true
-      })
-      psA.addEventListener(topic, receivedMsg)
+      psB.addEventListener('message', shouldNotHappen)
+      psA.addEventListener('message', receivedMsg)
 
       function receivedMsg (evt: CustomEvent<Message>) {
         const msg = evt.detail
         expect(uint8ArrayToString(msg.data)).to.equal('banana')
-        expect(msg.from.toString()).to.equal(peerIdB.toString())
+        expect(msg.from.toString()).to.equal(componentsB.getPeerId().toString())
         expect(msg.sequenceNumber).to.be.a('BigInt')
         expect(msg.topic).to.be.equal(topic)
 
         if (++counter === 10) {
-          psA.removeEventListener(topic, receivedMsg)
-          psB.removeEventListener(topic, shouldNotHappen)
+          psA.removeEventListener('message', receivedMsg)
+          psB.removeEventListener('message', shouldNotHappen)
 
           defer.resolve()
         }
       }
 
+      psA.subscribe(topic)
+      psB.subscribe(topic)
+
       await Promise.all([
-        waitForSubscriptionUpdate(psA, psB),
-        waitForSubscriptionUpdate(psB, psA)
+        waitForSubscriptionUpdate(psA, componentsB.getPeerId()),
+        waitForSubscriptionUpdate(psB, componentsA.getPeerId())
       ])
 
-      Array.from({ length: 10 }, (_, i) => psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('banana') })))
+      await Promise.all(
+        Array.from({ length: 10 }, async (_, i) => await psB.publish(topic, uint8ArrayFromString('banana')))
+      )
 
       return await defer.promise
     })
@@ -205,7 +196,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
       const defer = pDefer()
       let callCount = 0
 
-      psB.addEventListener('pubsub:subscription-change', (evt) => {
+      psB.addEventListener('subscription-change', (evt) => {
         callCount++
 
         if (callCount === 1) {
@@ -239,33 +230,5 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
 
       return await defer.promise
     })
-
-    it.skip('Publish to a topic:Z in nodeA nodeB', async () => {
-      const defer = pDefer()
-      const topic = 'Z'
-
-      psA.addEventListener(topic, shouldNotHappen, {
-        once: true
-      })
-      psB.addEventListener(topic, shouldNotHappen, {
-        once: true
-      })
-
-      await Promise.all([
-        waitForSubscriptionUpdate(psA, psB),
-        waitForSubscriptionUpdate(psB, psA)
-      ])
-
-      setTimeout(() => {
-        psA.removeEventListener(topic, shouldNotHappen)
-        psB.removeEventListener(topic, shouldNotHappen)
-        defer.resolve()
-      }, 100)
-
-      void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('banana') }))
-      void psA.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('banana') }))
-
-      return await defer.promise
-    })
   })
 }

package/src/pubsub/utils.ts

@@ -1,12 +1,23 @@
 import { pEvent } from 'p-event'
 import pWaitFor from 'p-wait-for'
-import type { SubscriptionChangeData } from '@libp2p/interfaces/pubsub'
-import type { PubSubBaseProtocol } from '@libp2p/pubsub'
+import { Components } from '@libp2p/interfaces/components'
+import type { PubSub, SubscriptionChangeData } from '@libp2p/interfaces/pubsub'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+import { mockConnectionManager, mockRegistrar } from '../mocks/index.js'
 
-export async function waitForSubscriptionUpdate (a: PubSubBaseProtocol, b: PubSubBaseProtocol) {
+export async function waitForSubscriptionUpdate (a: PubSub, b: PeerId) {
   await pWaitFor(async () => {
-    const event = await pEvent<'pubsub:subscription-change', CustomEvent<SubscriptionChangeData>>(a, 'pubsub:subscription-change')
+    const event = await pEvent<'subscription-change', CustomEvent<SubscriptionChangeData>>(a, 'subscription-change')
 
-    return event.detail.peerId.equals(b.components.getPeerId())
+    return event.detail.peerId.equals(b)
+  })
+}
+
+export async function createComponents (): Promise<Components> {
+  return new Components({
+    peerId: await createEd25519PeerId(),
+    registrar: mockRegistrar(),
+    connectionManager: mockConnectionManager()
   })
 }