@libp2p/interface-compliance-tests 1.1.21 → 1.1.24

package/src/pubsub/multiple-nodes.ts

@@ -7,27 +7,25 @@ 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 { 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 { start, stop } from '../index.js'
 
-export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
+export default (common: TestSetup<PubSub, PubSubArgs>) => {
   describe('pubsub with multiple nodes', function () {
     describe('every peer subscribes to the topic', () => {
       describe('line', () => {
         // line
         // ◉────◉────◉
         // a    b    c
-        let psA: PubSubBaseProtocol
-        let psB: PubSubBaseProtocol
-        let psC: PubSubBaseProtocol
+        let psA: PubSub
+        let psB: PubSub
+        let psC: PubSub
         let peerIdA: PeerId
         let peerIdB: PeerId
         let peerIdC: PeerId
@@ -116,7 +114,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
           psA.subscribe(topic)
           expect(psA.getTopics()).to.deep.equal([topic])
 
-          await waitForSubscriptionUpdate(psB, psA)
+          await waitForSubscriptionUpdate(psB, peerIdA)
 
           expect(psB.getPeers().length).to.equal(2)
           expect(psB.getSubscribers(topic).map(p => p.toString())).to.deep.equal([peerIdA.toString()])
@@ -131,8 +129,8 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
           expect(psB.getTopics()).to.deep.equal([topic])
 
           await Promise.all([
-            waitForSubscriptionUpdate(psA, psB),
-            waitForSubscriptionUpdate(psC, psB)
+            waitForSubscriptionUpdate(psA, peerIdB),
+            waitForSubscriptionUpdate(psC, peerIdB)
           ])
 
           expect(psA.getPeers().length).to.equal(1)
@@ -149,7 +147,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
           psC.subscribe(topic)
           expect(psC.getTopics()).to.deep.equal([topic])
 
-          psB.addEventListener('pubsub:subscription-change', () => {
+          psB.addEventListener('subscription-change', () => {
             expect(psA.getPeers().length).to.equal(1)
             expect(psB.getPeers().length).to.equal(2)
             expect(psB.getSubscribers(topic).map(p => p.toString())).to.deep.equal([peerIdC.toString()])
@@ -172,17 +170,29 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
 
           let counter = 0
 
-          psA.addEventListener(topic, incMsg)
-          psB.addEventListener(topic, incMsg)
-          psC.addEventListener(topic, incMsg)
+          psA.addEventListener('message', (evt) => {
+            if (evt.detail.topic === topic) {
+              incMsg(evt)
+            }
+          })
+          psB.addEventListener('message', (evt) => {
+            if (evt.detail.topic === topic) {
+              incMsg(evt)
+            }
+          })
+          psC.addEventListener('message', (evt) => {
+            if (evt.detail.topic === topic) {
+              incMsg(evt)
+            }
+          })
 
           await Promise.all([
-            waitForSubscriptionUpdate(psA, psB),
-            waitForSubscriptionUpdate(psB, psA),
-            waitForSubscriptionUpdate(psC, psB)
+            waitForSubscriptionUpdate(psA, peerIdB),
+            waitForSubscriptionUpdate(psB, peerIdA),
+            waitForSubscriptionUpdate(psC, peerIdB)
           ])
 
-          void psA.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('hey') }))
+          psA.publish(topic, uint8ArrayFromString('hey'))
 
           function incMsg (evt: CustomEvent<Message>) {
             const msg = evt.detail
@@ -192,9 +202,21 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
 
           function check () {
             if (++counter === 3) {
-              psA.removeEventListener(topic, incMsg)
-              psB.removeEventListener(topic, incMsg)
-              psC.removeEventListener(topic, incMsg)
+              psA.removeEventListener('message', (evt) => {
+                if (evt.detail.topic === topic) {
+                  incMsg(evt)
+                }
+              })
+              psB.removeEventListener('message', (evt) => {
+                if (evt.detail.topic === topic) {
+                  incMsg(evt)
+                }
+              })
+              psC.removeEventListener('message', (evt) => {
+                if (evt.detail.topic === topic) {
+                  incMsg(evt)
+                }
+              })
               defer.resolve()
             }
           }
@@ -216,34 +238,33 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
             const defer = pDefer()
             let counter = 0
 
+            psA.addEventListener('message', (evt) => {
+              if (evt.detail.topic === topic) {
+                incMsg(evt)
+              }
+            })
+            psB.addEventListener('message', (evt) => {
+              if (evt.detail.topic === topic) {
+                incMsg(evt)
+              }
+            })
+            psC.addEventListener('message', (evt) => {
+              if (evt.detail.topic === topic) {
+                incMsg(evt)
+              }
+            })
+
             psA.subscribe(topic)
             psB.subscribe(topic)
             psC.subscribe(topic)
 
-            // await subscription change
-            await Promise.all([
-              new Promise(resolve => psA.addEventListener('pubsub:subscription-change', () => resolve(null), {
-                once: true
-              })),
-              new Promise(resolve => psB.addEventListener('pubsub:subscription-change', () => resolve(null), {
-                once: true
-              })),
-              new Promise(resolve => psC.addEventListener('pubsub:subscription-change', () => resolve(null), {
-                once: true
-              }))
-            ])
-
-            psA.addEventListener(topic, incMsg)
-            psB.addEventListener(topic, incMsg)
-            psC.addEventListener(topic, incMsg)
-
             await Promise.all([
-              waitForSubscriptionUpdate(psA, psB),
-              waitForSubscriptionUpdate(psB, psA),
-              waitForSubscriptionUpdate(psC, psB)
+              waitForSubscriptionUpdate(psA, peerIdB),
+              waitForSubscriptionUpdate(psB, peerIdA),
+              waitForSubscriptionUpdate(psC, peerIdB)
             ])
 
-            void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('hey') }))
+            psB.publish(topic, uint8ArrayFromString('hey'))
 
             function incMsg (evt: CustomEvent<Message>) {
               const msg = evt.detail
@@ -253,9 +274,21 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
 
             function check () {
               if (++counter === 3) {
-                psA.removeEventListener(topic, incMsg)
-                psB.removeEventListener(topic, incMsg)
-                psC.removeEventListener(topic, incMsg)
+                psA.removeEventListener('message', (evt) => {
+                  if (evt.detail.topic === topic) {
+                    incMsg(evt)
+                  }
+                })
+                psB.removeEventListener('message', (evt) => {
+                  if (evt.detail.topic === topic) {
+                    incMsg(evt)
+                  }
+                })
+                psC.removeEventListener('message', (evt) => {
+                  if (evt.detail.topic === topic) {
+                    incMsg(evt)
+                  }
+                })
                 defer.resolve()
               }
             }
@@ -273,11 +306,11 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         //   │b     d│
         // ◉─┘       └─◉
         // a
-        let psA: PubSubBaseProtocol
-        let psB: PubSubBaseProtocol
-        let psC: PubSubBaseProtocol
-        let psD: PubSubBaseProtocol
-        let psE: PubSubBaseProtocol
+        let psA: PubSub
+        let psB: PubSub
+        let psC: PubSub
+        let psD: PubSub
+        let psE: PubSub
         let peerIdA: PeerId
         let peerIdB: PeerId
         let peerIdC: PeerId
@@ -415,27 +448,48 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         it('publishes from c', async function () {
           const defer = pDefer()
           let counter = 0
+          const topic = 'Z'
 
-          psA.subscribe('Z')
-          psA.addEventListener('Z', incMsg)
-          psB.subscribe('Z')
-          psB.addEventListener('Z', incMsg)
-          psC.subscribe('Z')
-          psC.addEventListener('Z', incMsg)
-          psD.subscribe('Z')
-          psD.addEventListener('Z', incMsg)
-          psE.subscribe('Z')
-          psE.addEventListener('Z', incMsg)
+          psA.subscribe(topic)
+          psA.addEventListener('message', (evt) => {
+            if (evt.detail.topic === topic) {
+              incMsg(evt)
+            }
+          })
+          psB.subscribe(topic)
+          psB.addEventListener('message', (evt) => {
+            if (evt.detail.topic === topic) {
+              incMsg(evt)
+            }
+          })
+          psC.subscribe(topic)
+          psC.addEventListener('message', (evt) => {
+            if (evt.detail.topic === topic) {
+              incMsg(evt)
+            }
+          })
+          psD.subscribe(topic)
+          psD.addEventListener('message', (evt) => {
+            if (evt.detail.topic === topic) {
+              incMsg(evt)
+            }
+          })
+          psE.subscribe(topic)
+          psE.addEventListener('message', (evt) => {
+            if (evt.detail.topic === topic) {
+              incMsg(evt)
+            }
+          })
 
           await Promise.all([
-            waitForSubscriptionUpdate(psA, psB),
-            waitForSubscriptionUpdate(psB, psA),
-            waitForSubscriptionUpdate(psC, psB),
-            waitForSubscriptionUpdate(psD, psC),
-            waitForSubscriptionUpdate(psE, psD)
+            waitForSubscriptionUpdate(psA, peerIdB),
+            waitForSubscriptionUpdate(psB, peerIdA),
+            waitForSubscriptionUpdate(psC, peerIdB),
+            waitForSubscriptionUpdate(psD, peerIdC),
+            waitForSubscriptionUpdate(psE, peerIdD)
           ])
 
-          void psC.dispatchEvent(new CustomEvent<Uint8Array>('Z', { detail: uint8ArrayFromString('hey from c') }))
+          psC.publish('Z', uint8ArrayFromString('hey from c'))
 
           function incMsg (evt: CustomEvent<Message>) {
             const msg = evt.detail

package/src/pubsub/two-nodes.ts

@@ -7,14 +7,12 @@ 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 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'
 
@@ -24,10 +22,10 @@ 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 psA: PubSub
+    let psB: PubSub
     let peerIdA: PeerId
     let peerIdB: PeerId
     let registrarA: Registrar
@@ -89,7 +87,7 @@ 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)
@@ -110,25 +108,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, peerIdB),
+        waitForSubscriptionUpdate(psB, peerIdA)
       ])
 
-      void psA.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('hey') }))
+      psA.publish(topic, uint8ArrayFromString('hey'))
 
       return await defer.promise
     })
@@ -136,16 +135,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 +160,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, peerIdB),
+        waitForSubscriptionUpdate(psB, peerIdA)
       ])
 
-      void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('banana') }))
+      psB.publish(topic, uint8ArrayFromString('banana'))
 
       return await defer.promise
     })
@@ -171,10 +179,8 @@ 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
@@ -184,19 +190,22 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         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, peerIdB),
+        waitForSubscriptionUpdate(psB, peerIdA)
       ])
 
-      Array.from({ length: 10 }, (_, i) => psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('banana') })))
+      Array.from({ length: 10 }, (_, i) => psB.publish(topic, uint8ArrayFromString('banana')))
 
       return await defer.promise
     })
@@ -205,7 +214,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 +248,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,12 @@
 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 type { PubSub, SubscriptionChangeData } from '@libp2p/interfaces/pubsub'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
 
-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)
   })
 }