@libp2p/interface-compliance-tests 1.1.7 → 1.1.11

package/src/pubsub/multiple-nodes.ts

@@ -1,56 +1,102 @@
 /* eslint max-nested-callbacks: ["error", 6] */
 import { expect } from 'aegir/utils/chai.js'
 import sinon from 'sinon'
-import delay from 'delay'
 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 { expectSet } from './utils.js'
+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 { PubSub, Message } from '@libp2p/interfaces/pubsub'
+import type { Message, PubSubOptions } from '@libp2p/interfaces/pubsub'
 import type { EventMap } from './index.js'
+import type { PeerId } from '@libp2p/interfaces/src/peer-id'
+import type { Registrar } from '@libp2p/interfaces/src/registrar'
+import type { PubsubBaseProtocol } from '@libp2p/pubsub'
 
-export default (common: TestSetup<PubSub<EventMap>>) => {
+export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>) => {
   describe('pubsub with multiple nodes', function () {
     describe('every peer subscribes to the topic', () => {
       describe('line', () => {
         // line
         // ◉────◉────◉
         // a    b    c
-        let psA: PubSub<EventMap>
-        let psB: PubSub<EventMap>
-        let psC: PubSub<EventMap>
+        let psA: PubsubBaseProtocol<EventMap>
+        let psB: PubsubBaseProtocol<EventMap>
+        let psC: PubsubBaseProtocol<EventMap>
+        let peerIdA: PeerId
+        let peerIdB: PeerId
+        let peerIdC: PeerId
+        let registrarA: Registrar
+        let registrarB: Registrar
+        let registrarC: Registrar
 
         // Create and start pubsub nodes
         beforeEach(async () => {
-          psA = await common.setup()
-          psB = await common.setup()
-          psC = await common.setup()
+          peerIdA = await createEd25519PeerId()
+          peerIdB = await createEd25519PeerId()
+          peerIdC = await createEd25519PeerId()
+
+          registrarA = mockRegistrar()
+          registrarB = mockRegistrar()
+          registrarC = mockRegistrar()
+
+          psA = await common.setup({
+            peerId: peerIdA,
+            registrar: registrarA,
+            emitSelf: true
+          })
+          psB = await common.setup({
+            peerId: peerIdB,
+            registrar: registrarB,
+            emitSelf: true
+          })
+          psC = await common.setup({
+            peerId: peerIdC,
+            registrar: registrarC,
+            emitSelf: true
+          })
 
           // Start pubsub modes
-          ;[psA, psB, psC].map((p) => p.start())
+          await Promise.all(
+            [psA, psB, psC].map(async (p) => await p.start())
+          )
         })
 
         // Connect nodes
         beforeEach(async () => {
-          // @ts-expect-error protected field
-          await psA._libp2p.dial(psB.peerId)
-          // @ts-expect-error protected field
-          await psB._libp2p.dial(psC.peerId)
+          await connectPeers(psA.multicodecs[0], {
+            peerId: peerIdA,
+            registrar: registrarA
+          }, {
+            peerId: peerIdB,
+            registrar: registrarB
+          })
+          await connectPeers(psA.multicodecs[0], {
+            peerId: peerIdB,
+            registrar: registrarB
+          }, {
+            peerId: peerIdC,
+            registrar: registrarC
+          })
 
           // Wait for peers to be ready in pubsub
           await pWaitFor(() =>
-            psA.peers.size === 1 &&
-            psC.peers.size === 1 &&
-            psA.peers.size === 1
+            psA.getPeers().length === 1 &&
+            psC.getPeers().length === 1 &&
+            psA.getPeers().length === 1
           )
         })
 
         afterEach(async () => {
           sinon.restore()
 
-          ;[psA, psB, psC].map((p) => p.stop())
+          await Promise.all(
+            [psA, psB, psC].map(async (p) => await p.stop())
+          )
+
           await common.teardown()
         })
 
@@ -58,39 +104,32 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
           const topic = 'Z'
 
           psA.subscribe(topic)
-          expectSet(psA.subscriptions, [topic])
+          expect(psA.getTopics()).to.deep.equal([topic])
 
-          await new Promise((resolve) => psB.addEventListener('pubsub:subscription-change', resolve, {
-            once: true
-          }))
-          expect(psB.peers.size).to.equal(2)
+          await waitForSubscriptionUpdate(psB, psA)
 
-          const aPeerId = psA.peerId.toString()
-          expectSet(psB.topics.get(topic), [aPeerId])
+          expect(psB.getPeers().length).to.equal(2)
+          expect(psB.getSubscribers(topic).map(p => p.toString())).to.deep.equal([peerIdA.toString()])
 
-          expect(psC.peers.size).to.equal(1)
-          expect(psC.topics.get(topic)).to.eql(undefined)
+          expect(psC.getPeers().length).to.equal(1)
+          expect(psC.getSubscribers(topic)).to.be.empty()
         })
 
         it('subscribe to the topic on node b', async () => {
           const topic = 'Z'
           psB.subscribe(topic)
-          expectSet(psB.subscriptions, [topic])
+          expect(psB.getTopics()).to.deep.equal([topic])
 
           await Promise.all([
-            new Promise((resolve) => psA.addEventListener('pubsub:subscription-change', resolve, {
-              once: true
-            })),
-            new Promise((resolve) => psC.addEventListener('pubsub:subscription-change', resolve, {
-              once: true
-            }))
+            waitForSubscriptionUpdate(psA, psB),
+            waitForSubscriptionUpdate(psC, psB)
           ])
 
-          expect(psA.peers.size).to.equal(1)
-          expectSet(psA.topics.get(topic), [psB.peerId.toString()])
+          expect(psA.getPeers().length).to.equal(1)
+          expect(psA.getSubscribers(topic).map(p => p.toString())).to.deep.equal([peerIdB.toString()])
 
-          expect(psC.peers.size).to.equal(1)
-          expectSet(psC.topics.get(topic), [psB.peerId.toString()])
+          expect(psC.getPeers().length).to.equal(1)
+          expect(psC.getSubscribers(topic).map(p => p.toString())).to.deep.equal([peerIdB.toString()])
         })
 
         it('subscribe to the topic on node c', async () => {
@@ -98,12 +137,12 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
           const defer = pDefer()
 
           psC.subscribe(topic)
-          expectSet(psC.subscriptions, [topic])
+          expect(psC.getTopics()).to.deep.equal([topic])
 
           psB.addEventListener('pubsub:subscription-change', () => {
-            expect(psA.peers.size).to.equal(1)
-            expect(psB.peers.size).to.equal(2)
-            expectSet(psB.topics.get(topic), [psC.peerId.toString()])
+            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()])
 
             defer.resolve()
           }, {
@@ -121,29 +160,19 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
           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
-            }))
-          ])
-
-          // await a cycle
-          await delay(1000)
-
           let counter = 0
 
           psA.addEventListener(topic, incMsg)
           psB.addEventListener(topic, incMsg)
           psC.addEventListener(topic, incMsg)
 
-          void psA.publish(topic, uint8ArrayFromString('hey'))
+          await Promise.all([
+            waitForSubscriptionUpdate(psA, psB),
+            waitForSubscriptionUpdate(psB, psA),
+            waitForSubscriptionUpdate(psC, psB)
+          ])
+
+          void psA.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('hey') }))
 
           function incMsg (evt: CustomEvent<Message>) {
             const msg = evt.detail
@@ -198,10 +227,13 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
             psB.addEventListener(topic, incMsg)
             psC.addEventListener(topic, incMsg)
 
-            // await a cycle
-            await delay(1000)
+            await Promise.all([
+              waitForSubscriptionUpdate(psA, psB),
+              waitForSubscriptionUpdate(psB, psA),
+              waitForSubscriptionUpdate(psC, psB)
+            ])
 
-            void psB.publish(topic, uint8ArrayFromString('hey'))
+            void psB.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('hey') }))
 
             function incMsg (evt: CustomEvent<Message>) {
               const msg = evt.detail
@@ -231,61 +263,127 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
         //   │b     d│
         // ◉─┘       └─◉
         // a
-        let psA: PubSub<EventMap>
-        let psB: PubSub<EventMap>
-        let psC: PubSub<EventMap>
-        let psD: PubSub<EventMap>
-        let psE: PubSub<EventMap>
+        let psA: PubsubBaseProtocol<EventMap>
+        let psB: PubsubBaseProtocol<EventMap>
+        let psC: PubsubBaseProtocol<EventMap>
+        let psD: PubsubBaseProtocol<EventMap>
+        let psE: PubsubBaseProtocol<EventMap>
+        let peerIdA: PeerId
+        let peerIdB: PeerId
+        let peerIdC: PeerId
+        let peerIdD: PeerId
+        let peerIdE: PeerId
+        let registrarA: Registrar
+        let registrarB: Registrar
+        let registrarC: Registrar
+        let registrarD: Registrar
+        let registrarE: Registrar
 
         // Create and start pubsub nodes
         beforeEach(async () => {
-          psA = await common.setup()
-          psB = await common.setup()
-          psC = await common.setup()
-          psD = await common.setup()
-          psE = await common.setup()
+          peerIdA = await createEd25519PeerId()
+          peerIdB = await createEd25519PeerId()
+          peerIdC = await createEd25519PeerId()
+          peerIdD = await createEd25519PeerId()
+          peerIdE = await createEd25519PeerId()
+
+          registrarA = mockRegistrar()
+          registrarB = mockRegistrar()
+          registrarC = mockRegistrar()
+          registrarD = mockRegistrar()
+          registrarE = mockRegistrar()
+
+          psA = await common.setup({
+            peerId: peerIdA,
+            registrar: registrarA,
+            emitSelf: true
+          })
+          psB = await common.setup({
+            peerId: peerIdB,
+            registrar: registrarB,
+            emitSelf: true
+          })
+          psC = await common.setup({
+            peerId: peerIdC,
+            registrar: registrarC,
+            emitSelf: true
+          })
+          psD = await common.setup({
+            peerId: peerIdD,
+            registrar: registrarD,
+            emitSelf: true
+          })
+          psE = await common.setup({
+            peerId: peerIdE,
+            registrar: registrarE,
+            emitSelf: true
+          })
 
           // Start pubsub nodes
-          ;[psA, psB, psC, psD, psE].map((p) => p.start())
+          await Promise.all(
+            [psA, psB, psC, psD, psE].map(async (p) => await p.start())
+          )
         })
 
         // connect nodes
         beforeEach(async () => {
-          // @ts-expect-error protected field
-          await psA._libp2p.dial(psB.peerId)
-          // @ts-expect-error protected field
-          await psB._libp2p.dial(psC.peerId)
-          // @ts-expect-error protected field
-          await psC._libp2p.dial(psD.peerId)
-          // @ts-expect-error protected field
-          await psD._libp2p.dial(psE.peerId)
+          await connectPeers(psA.multicodecs[0], {
+            peerId: peerIdA,
+            registrar: registrarA
+          }, {
+            peerId: peerIdB,
+            registrar: registrarB
+          })
+          await connectPeers(psA.multicodecs[0], {
+            peerId: peerIdB,
+            registrar: registrarB
+          }, {
+            peerId: peerIdC,
+            registrar: registrarC
+          })
+          await connectPeers(psA.multicodecs[0], {
+            peerId: peerIdC,
+            registrar: registrarC
+          }, {
+            peerId: peerIdD,
+            registrar: registrarD
+          })
+          await connectPeers(psA.multicodecs[0], {
+            peerId: peerIdD,
+            registrar: registrarD
+          }, {
+            peerId: peerIdE,
+            registrar: registrarE
+          })
 
           // Wait for peers to be ready in pubsub
           await pWaitFor(() =>
-            psA.peers.size === 1 &&
-            psB.peers.size === 2 &&
-            psC.peers.size === 2 &&
-            psD.peers.size === 2 &&
-            psE.peers.size === 1
+            psA.getPeers().length === 1 &&
+            psB.getPeers().length === 2 &&
+            psC.getPeers().length === 2 &&
+            psD.getPeers().length === 2 &&
+            psE.getPeers().length === 1
           )
         })
 
         afterEach(async () => {
-          [psA, psB, psC, psD, psE].map((p) => p.stop())
+          await Promise.all(
+            [psA, psB, psC, psD, psE].map(async (p) => await p.stop())
+          )
           await common.teardown()
         })
 
         it('subscribes', () => {
           psA.subscribe('Z')
-          expectSet(psA.subscriptions, ['Z'])
+          expect(psA.getTopics()).to.deep.equal(['Z'])
           psB.subscribe('Z')
-          expectSet(psB.subscriptions, ['Z'])
+          expect(psB.getTopics()).to.deep.equal(['Z'])
           psC.subscribe('Z')
-          expectSet(psC.subscriptions, ['Z'])
+          expect(psC.getTopics()).to.deep.equal(['Z'])
           psD.subscribe('Z')
-          expectSet(psD.subscriptions, ['Z'])
+          expect(psD.getTopics()).to.deep.equal(['Z'])
           psE.subscribe('Z')
-          expectSet(psE.subscriptions, ['Z'])
+          expect(psE.getTopics()).to.deep.equal(['Z'])
         })
 
         it('publishes from c', async function () {
@@ -304,17 +402,14 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
           psE.addEventListener('Z', incMsg)
 
           await Promise.all([
-            new Promise((resolve) => psA.addEventListener('pubsub:subscription-change', resolve)),
-            new Promise((resolve) => psB.addEventListener('pubsub:subscription-change', resolve)),
-            new Promise((resolve) => psC.addEventListener('pubsub:subscription-change', resolve)),
-            new Promise((resolve) => psD.addEventListener('pubsub:subscription-change', resolve)),
-            new Promise((resolve) => psE.addEventListener('pubsub:subscription-change', resolve))
+            waitForSubscriptionUpdate(psA, psB),
+            waitForSubscriptionUpdate(psB, psA),
+            waitForSubscriptionUpdate(psC, psB),
+            waitForSubscriptionUpdate(psD, psC),
+            waitForSubscriptionUpdate(psE, psD)
           ])
 
-          // await a cycle
-          await delay(1000)
-
-          void psC.publish('Z', uint8ArrayFromString('hey from c'))
+          void psC.dispatchEvent(new CustomEvent('Z', { detail: uint8ArrayFromString('hey from c') }))
 
           function incMsg (evt: CustomEvent<Message>) {
             const msg = evt.detail

package/src/pubsub/two-nodes.ts

@@ -5,13 +5,16 @@ 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 type { TestSetup } from '../index.js'
-import type { PubSub, Message } from '@libp2p/interfaces/pubsub'
-import {
-  first,
-  expectSet
-} from './utils.js'
+import type { Message, PubSubOptions } from '@libp2p/interfaces/pubsub'
 import type { EventMap } from './index.js'
+import type { PeerId } from '@libp2p/interfaces/src/peer-id'
+import type { Registrar } from '@libp2p/interfaces/src/registrar'
+import type { PubsubBaseProtocol } from '@libp2p/pubsub'
 
 const topic = 'foo'
 
@@ -19,31 +22,54 @@ function shouldNotHappen () {
   expect.fail()
 }
 
-export default (common: TestSetup<PubSub<EventMap>>) => {
+export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>) => {
   describe('pubsub with two nodes', () => {
-    let psA: PubSub<EventMap>
-    let psB: PubSub<EventMap>
+    let psA: PubsubBaseProtocol<EventMap>
+    let psB: PubsubBaseProtocol<EventMap>
+    let peerIdA: PeerId
+    let peerIdB: PeerId
+    let registrarA: Registrar
+    let registrarB: Registrar
 
     // Create pubsub nodes and connect them
-    before(async () => {
-      psA = await common.setup()
-      psB = await common.setup()
+    beforeEach(async () => {
+      peerIdA = await createEd25519PeerId()
+      peerIdB = await createEd25519PeerId()
 
-      expect(psA.peers.size).to.be.eql(0)
-      expect(psB.peers.size).to.be.eql(0)
+      registrarA = mockRegistrar()
+      registrarB = mockRegistrar()
+
+      psA = await common.setup({
+        peerId: peerIdA,
+        registrar: registrarA,
+        emitSelf: true
+      })
+      psB = await common.setup({
+        peerId: peerIdB,
+        registrar: registrarB,
+        emitSelf: false
+      })
 
       // Start pubsub and connect nodes
       await psA.start()
       await psB.start()
 
-      // @ts-expect-error protected property
-      await psA._libp2p.dial(psB.peerId)
+      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
+      })
 
       // Wait for peers to be ready in pubsub
-      await pWaitFor(() => psA.peers.size === 1 && psB.peers.size === 1)
+      await pWaitFor(() => psA.getPeers().length === 1 && psB.getPeers().length === 1)
     })
 
-    after(async () => {
+    afterEach(async () => {
       sinon.restore()
 
       await psA.stop()
@@ -57,12 +83,12 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
 
       psB.addEventListener('pubsub:subscription-change', (evt) => {
         const { peerId: changedPeerId, subscriptions: changedSubs } = evt.detail
-        expectSet(psA.subscriptions, [topic])
-        expect(psB.peers.size).to.equal(1)
-        expectSet(psB.topics.get(topic), [psA.peerId.toString()])
-        expect(changedPeerId.toString()).to.equal(first(psB.peers).id.toString())
+        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(changedPeerId).to.deep.equal(psB.getPeers()[0])
         expect(changedSubs).to.have.lengthOf(1)
-        expect(changedSubs[0].topicID).to.equal(topic)
+        expect(changedSubs[0].topic).to.equal(topic)
         expect(changedSubs[0].subscribe).to.equal(true)
         defer.resolve()
       }, {
@@ -89,7 +115,12 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
         once: true
       })
 
-      void psA.publish(topic, uint8ArrayFromString('hey'))
+      await Promise.all([
+        waitForSubscriptionUpdate(psA, psB),
+        waitForSubscriptionUpdate(psB, psA)
+      ])
+
+      void psA.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('hey') }))
 
       return await defer.promise
     })
@@ -118,7 +149,12 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
         once: true
       })
 
-      void psB.publish(topic, uint8ArrayFromString('banana'))
+      await Promise.all([
+        waitForSubscriptionUpdate(psA, psB),
+        waitForSubscriptionUpdate(psB, psA)
+      ])
+
+      void psB.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('banana') }))
 
       return await defer.promise
     })
@@ -135,9 +171,9 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
       function receivedMsg (evt: CustomEvent<Message>) {
         const msg = evt.detail
         expect(uint8ArrayToString(msg.data)).to.equal('banana')
-        expect(msg.from).to.be.eql(psB.peerId.toString())
-        expect(msg.seqno).to.be.a('Uint8Array')
-        expect(msg.topicIDs).to.be.eql([topic])
+        expect(msg.from.toString()).to.equal(peerIdB.toString())
+        expect(msg.seqno).to.be.a('BigInt')
+        expect(msg.topic).to.be.equal(topic)
 
         if (++counter === 10) {
           psA.removeEventListener(topic, receivedMsg)
@@ -147,52 +183,79 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
         }
       }
 
-      Array.from({ length: 10 }, async (_, i) => await psB.publish(topic, uint8ArrayFromString('banana')))
+      await Promise.all([
+        waitForSubscriptionUpdate(psA, psB),
+        waitForSubscriptionUpdate(psB, psA)
+      ])
+
+      Array.from({ length: 10 }, (_, i) => psB.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('banana') })))
 
       return await defer.promise
     })
 
     it('Unsubscribe from topic in nodeA', async () => {
       const defer = pDefer()
-
-      psA.unsubscribe(topic)
-      expect(psA.subscriptions.size).to.equal(0)
+      let callCount = 0
 
       psB.addEventListener('pubsub:subscription-change', (evt) => {
-        const { peerId: changedPeerId, subscriptions: changedSubs } = evt.detail
-        expect(psB.peers.size).to.equal(1)
-        expectSet(psB.topics.get(topic), [])
-        expect(changedPeerId.toString()).to.equal(first(psB.peers).id.toString())
-        expect(changedSubs).to.have.lengthOf(1)
-        expect(changedSubs[0].topicID).to.equal(topic)
-        expect(changedSubs[0].subscribe).to.equal(false)
+        callCount++
+
+        if (callCount === 1) {
+          // notice subscribe
+          const { peerId: changedPeerId, subscriptions: changedSubs } = evt.detail
+          expect(psB.getPeers()).to.have.lengthOf(1)
+          expect(psB.getTopics()).to.be.empty()
+          expect(changedPeerId).to.deep.equal(psB.getPeers()[0])
+          expect(changedSubs).to.have.lengthOf(1)
+          expect(changedSubs[0].topic).to.equal(topic)
+          expect(changedSubs[0].subscribe).to.equal(true)
+        } else {
+          // notice unsubscribe
+          const { peerId: changedPeerId, subscriptions: changedSubs } = evt.detail
+          expect(psB.getPeers()).to.have.lengthOf(1)
+          expect(psB.getTopics()).to.be.empty()
+          expect(changedPeerId).to.deep.equal(psB.getPeers()[0])
+          expect(changedSubs).to.have.lengthOf(1)
+          expect(changedSubs[0].topic).to.equal(topic)
+          expect(changedSubs[0].subscribe).to.equal(false)
 
-        defer.resolve()
-      }, {
-        once: true
+          defer.resolve()
+        }
       })
 
+      psA.subscribe(topic)
+      expect(psA.getTopics()).to.not.be.empty()
+
+      psA.unsubscribe(topic)
+      expect(psA.getTopics()).to.be.empty()
+
       return await defer.promise
     })
 
-    it('Publish to a topic:Z in nodeA nodeB', async () => {
+    it.skip('Publish to a topic:Z in nodeA nodeB', async () => {
       const defer = pDefer()
+      const topic = 'Z'
 
-      psA.addEventListener('Z', shouldNotHappen, {
+      psA.addEventListener(topic, shouldNotHappen, {
         once: true
       })
-      psB.addEventListener('Z', shouldNotHappen, {
+      psB.addEventListener(topic, shouldNotHappen, {
         once: true
       })
 
+      await Promise.all([
+        waitForSubscriptionUpdate(psA, psB),
+        waitForSubscriptionUpdate(psB, psA)
+      ])
+
       setTimeout(() => {
-        psA.removeEventListener('Z', shouldNotHappen)
-        psB.removeEventListener('Z', shouldNotHappen)
+        psA.removeEventListener(topic, shouldNotHappen)
+        psB.removeEventListener(topic, shouldNotHappen)
         defer.resolve()
       }, 100)
 
-      void psB.publish('Z', uint8ArrayFromString('banana'))
-      void psA.publish('Z', uint8ArrayFromString('banana'))
+      void psB.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('banana') }))
+      void psA.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('banana') }))
 
       return await defer.promise
     })