@libp2p/interface-compliance-tests 6.4.16 → 6.5.0-8484de8a2

package/src/pubsub/multiple-nodes.ts

@@ -1,440 +0,0 @@
-/* eslint max-nested-callbacks: ["error", 6] */
-import { start, stop } from '@libp2p/interface'
-import { expect } from 'aegir/chai'
-import delay from 'delay'
-import pDefer from 'p-defer'
-import pWaitFor from 'p-wait-for'
-import sinon from 'sinon'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { mockNetwork } from '../mocks/index.js'
-import { createComponents, waitForSubscriptionUpdate } from './utils.js'
-import type { PubSubArgs, PubSubComponents } from './index.js'
-import type { TestSetup } from '../index.js'
-import type { Message, PubSub } from '@libp2p/interface'
-
-export default (common: TestSetup<PubSub, PubSubArgs>): void => {
-  describe('pubsub with multiple nodes', function () {
-    describe('every peer subscribes to the topic', () => {
-      describe('line', () => {
-        // line
-        // ◉────◉────◉
-        // a    b    c
-        let psA: PubSub
-        let psB: PubSub
-        let psC: PubSub
-        let componentsA: PubSubComponents
-        let componentsB: PubSubComponents
-        let componentsC: PubSubComponents
-
-        // Create and start pubsub nodes
-        beforeEach(async () => {
-          mockNetwork.reset()
-
-          componentsA = await createComponents()
-          componentsB = await createComponents()
-          componentsC = await createComponents()
-
-          psA = componentsA.pubsub = await common.setup({
-            components: componentsA,
-            init: {
-              emitSelf: true
-            }
-          })
-          psB = componentsB.pubsub = await common.setup({
-            components: componentsB,
-            init: {
-              emitSelf: true
-            }
-          })
-          psC = componentsC.pubsub = await common.setup({
-            components: componentsC,
-            init: {
-              emitSelf: true
-            }
-          })
-
-          // Start pubsub modes
-          await start(...Object.values(componentsA), ...Object.values(componentsB), ...Object.values(componentsC))
-
-          // Connect nodes
-          await componentsA.connectionManager.openConnection(componentsB.peerId)
-          await componentsB.connectionManager.openConnection(componentsC.peerId)
-
-          // Wait for peers to be ready in pubsub
-          await pWaitFor(() =>
-            psA.getPeers().length === 1 &&
-            psC.getPeers().length === 1 &&
-            psA.getPeers().length === 1
-          )
-        })
-
-        afterEach(async () => {
-          sinon.restore()
-          await stop(...Object.values(componentsA), ...Object.values(componentsB), ...Object.values(componentsC))
-          await common.teardown()
-          mockNetwork.reset()
-        })
-
-        it('subscribe to the topic on node a', async () => {
-          const topic = 'Z'
-
-          psA.subscribe(topic)
-          expect(psA.getTopics()).to.deep.equal([topic])
-
-          await waitForSubscriptionUpdate(psB, componentsA.peerId)
-
-          expect(psB.getPeers().length).to.equal(2)
-          expect(psB.getSubscribers(topic).map(p => p.toString())).to.deep.equal([componentsA.peerId.toString()])
-
-          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)
-          expect(psB.getTopics()).to.deep.equal([topic])
-
-          await Promise.all([
-            waitForSubscriptionUpdate(psA, componentsB.peerId),
-            waitForSubscriptionUpdate(psC, componentsB.peerId)
-          ])
-
-          expect(psA.getPeers().length).to.equal(1)
-          expect(psA.getSubscribers(topic).map(p => p.toString())).to.deep.equal([componentsB.peerId.toString()])
-
-          expect(psC.getPeers().length).to.equal(1)
-          expect(psC.getSubscribers(topic).map(p => p.toString())).to.deep.equal([componentsB.peerId.toString()])
-        })
-
-        it('subscribe to the topic on node c', async () => {
-          const topic = 'Z'
-          const defer = pDefer()
-
-          psC.subscribe(topic)
-          expect(psC.getTopics()).to.deep.equal([topic])
-
-          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([componentsC.peerId.toString()])
-
-            defer.resolve()
-          }, {
-            once: true
-          })
-
-          return defer.promise
-        })
-
-        it('publish on node a', async () => {
-          const topic = 'Z'
-          const defer = pDefer()
-
-          psA.subscribe(topic)
-          psB.subscribe(topic)
-          psC.subscribe(topic)
-
-          await Promise.all([
-            waitForSubscriptionUpdate(psA, componentsB.peerId),
-            waitForSubscriptionUpdate(psB, componentsA.peerId),
-            waitForSubscriptionUpdate(psC, componentsB.peerId)
-          ])
-
-          // GossipSub needs time to build the mesh overlay
-          await delay(1000)
-
-          let counter = 0
-
-          psA.addEventListener('message', incMsg)
-          psB.addEventListener('message', incMsg)
-          psC.addEventListener('message', incMsg)
-
-          const result = await psA.publish(topic, uint8ArrayFromString('hey'))
-
-          expect(result).to.have.property('recipients').with.property('length').greaterThanOrEqual(1)
-
-          function incMsg (evt: CustomEvent<Message>): void {
-            const msg = evt.detail
-
-            if (msg.topic !== topic) {
-              return
-            }
-
-            expect(uint8ArrayToString(msg.data)).to.equal('hey')
-            check()
-          }
-
-          function check (): void {
-            if (++counter === 3) {
-              psA.removeEventListener('message', incMsg)
-              psB.removeEventListener('message', incMsg)
-              psC.removeEventListener('message', incMsg)
-              defer.resolve()
-            }
-          }
-
-          return defer.promise
-        })
-
-        // since the topology is the same, just the publish
-        // gets sent by other peer, we reused the same peers
-        describe('1 level tree', () => {
-          // 1 level tree
-          //     ┌◉┐
-          //     │b│
-          //   ◉─┘ └─◉
-          //   a     c
-
-          it('publish on node b', async () => {
-            const topic = 'Z'
-            const defer = pDefer()
-            let counter = 0
-
-            psA.subscribe(topic)
-            psB.subscribe(topic)
-            psC.subscribe(topic)
-
-            await Promise.all([
-              waitForSubscriptionUpdate(psA, componentsB.peerId),
-              waitForSubscriptionUpdate(psB, componentsA.peerId),
-              waitForSubscriptionUpdate(psC, componentsB.peerId)
-            ])
-
-            // GossipSub needs time to build the mesh overlay
-            await delay(1000)
-
-            psA.addEventListener('message', incMsg)
-            psB.addEventListener('message', incMsg)
-            psC.addEventListener('message', incMsg)
-
-            await psB.publish(topic, uint8ArrayFromString('hey'))
-
-            function incMsg (evt: CustomEvent<Message>): void {
-              const msg = evt.detail
-
-              if (msg.topic !== topic) {
-                return
-              }
-
-              expect(uint8ArrayToString(msg.data)).to.equal('hey')
-              check()
-            }
-
-            function check (): void {
-              if (++counter === 3) {
-                psA.removeEventListener('message', incMsg)
-                psB.removeEventListener('message', incMsg)
-                psC.removeEventListener('message', incMsg)
-                defer.resolve()
-              }
-            }
-
-            return defer.promise
-          })
-        })
-      })
-
-      describe('2 level tree', () => {
-        // 2 levels tree
-        //      ┌◉┐
-        //      │c│
-        //   ┌◉─┘ └─◉┐
-        //   │b     d│
-        // ◉─┘       └─◉
-        // a
-        let psA: PubSub
-        let psB: PubSub
-        let psC: PubSub
-        let psD: PubSub
-        let psE: PubSub
-        let componentsA: PubSubComponents
-        let componentsB: PubSubComponents
-        let componentsC: PubSubComponents
-        let componentsD: PubSubComponents
-        let componentsE: PubSubComponents
-
-        // Create and start pubsub nodes
-        beforeEach(async () => {
-          mockNetwork.reset()
-
-          componentsA = await createComponents()
-          componentsB = await createComponents()
-          componentsC = await createComponents()
-          componentsD = await createComponents()
-          componentsE = await createComponents()
-
-          psA = componentsA.pubsub = await common.setup({
-            components: componentsA,
-            init: {
-              emitSelf: true
-            }
-          })
-          psB = componentsB.pubsub = await common.setup({
-            components: componentsB,
-            init: {
-              emitSelf: true
-            }
-          })
-          psC = componentsC.pubsub = await common.setup({
-            components: componentsC,
-            init: {
-              emitSelf: true
-            }
-          })
-          psD = componentsD.pubsub = await common.setup({
-            components: componentsD,
-            init: {
-              emitSelf: true
-            }
-          })
-          psE = componentsE.pubsub = await common.setup({
-            components: componentsE,
-            init: {
-              emitSelf: true
-            }
-          })
-
-          // Start pubsub nodes
-          await start(
-            ...Object.values(componentsA),
-            ...Object.values(componentsB),
-            ...Object.values(componentsC),
-            ...Object.values(componentsD),
-            ...Object.values(componentsE)
-          )
-
-          // connect nodes
-          await componentsA.connectionManager.openConnection(componentsB.peerId)
-          await componentsB.connectionManager.openConnection(componentsC.peerId)
-          await componentsC.connectionManager.openConnection(componentsD.peerId)
-          await componentsD.connectionManager.openConnection(componentsE.peerId)
-
-          // Wait for peers to be ready in pubsub
-          await pWaitFor(() =>
-            psA.getPeers().length === 1 &&
-            psB.getPeers().length === 2 &&
-            psC.getPeers().length === 2 &&
-            psD.getPeers().length === 2 &&
-            psE.getPeers().length === 1
-          )
-        })
-
-        afterEach(async () => {
-          await stop(
-            ...Object.values(componentsA),
-            ...Object.values(componentsB),
-            ...Object.values(componentsC),
-            ...Object.values(componentsD),
-            ...Object.values(componentsE)
-          )
-          await common.teardown()
-          mockNetwork.reset()
-        })
-
-        it('subscribes', () => {
-          psA.subscribe('Z')
-          expect(psA.getTopics()).to.deep.equal(['Z'])
-          psB.subscribe('Z')
-          expect(psB.getTopics()).to.deep.equal(['Z'])
-          psC.subscribe('Z')
-          expect(psC.getTopics()).to.deep.equal(['Z'])
-          psD.subscribe('Z')
-          expect(psD.getTopics()).to.deep.equal(['Z'])
-          psE.subscribe('Z')
-          expect(psE.getTopics()).to.deep.equal(['Z'])
-        })
-
-        it('publishes from c', async function () {
-          const defer = pDefer()
-          let counter = 0
-          const topic = 'Z'
-
-          psA.subscribe(topic)
-          psA.addEventListener('message', incMsg)
-          psB.subscribe(topic)
-          psB.addEventListener('message', incMsg)
-          psC.subscribe(topic)
-          psC.addEventListener('message', incMsg)
-          psD.subscribe(topic)
-          psD.addEventListener('message', incMsg)
-          psE.subscribe(topic)
-          psE.addEventListener('message', incMsg)
-
-          await Promise.all([
-            waitForSubscriptionUpdate(psA, componentsB.peerId),
-            waitForSubscriptionUpdate(psB, componentsA.peerId),
-            waitForSubscriptionUpdate(psC, componentsB.peerId),
-            waitForSubscriptionUpdate(psD, componentsC.peerId),
-            waitForSubscriptionUpdate(psE, componentsD.peerId)
-          ])
-
-          // GossipSub needs time to build the mesh overlay
-          await delay(1000)
-
-          await psC.publish('Z', uint8ArrayFromString('hey from c'))
-
-          function incMsg (evt: CustomEvent<Message>): void {
-            const msg = evt.detail
-
-            if (msg.topic !== topic) {
-              return
-            }
-
-            expect(uint8ArrayToString(msg.data)).to.equal('hey from c')
-            check()
-          }
-
-          function check (): void {
-            if (++counter === 5) {
-              psA.unsubscribe('Z')
-              psB.unsubscribe('Z')
-              psC.unsubscribe('Z')
-              psD.unsubscribe('Z')
-              psE.unsubscribe('Z')
-              defer.resolve()
-            }
-          }
-
-          return defer.promise
-        })
-      })
-    })
-
-    describe('only some nodes subscribe the networks', () => {
-      describe('line', () => {
-        // line
-        // ◉────◎────◉
-        // a    b    c
-
-        before(() => { })
-        after(() => { })
-      })
-
-      describe('1 level tree', () => {
-        // 1 level tree
-        //     ┌◉┐
-        //     │b│
-        //   ◎─┘ └─◉
-        //   a     c
-
-        before(() => { })
-        after(() => { })
-      })
-
-      describe('2 level tree', () => {
-        // 2 levels tree
-        //      ┌◉┐
-        //      │c│
-        //   ┌◎─┘ └─◉┐
-        //   │b     d│
-        // ◉─┘       └─◎
-        // a           e
-
-        before(() => { })
-        after(() => { })
-      })
-    })
-  })
-}

package/src/pubsub/two-nodes.ts

@@ -1,272 +0,0 @@
-/* eslint max-nested-callbacks: ["error", 6] */
-import { TopicValidatorResult, start, stop } from '@libp2p/interface'
-import { expect } from 'aegir/chai'
-import pDefer from 'p-defer'
-import pWaitFor from 'p-wait-for'
-import sinon from 'sinon'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { mockNetwork } from '../mocks/index.js'
-import { createComponents, waitForSubscriptionUpdate } from './utils.js'
-import type { PubSubArgs, PubSubComponents } from './index.js'
-import type { TestSetup } from '../index.js'
-import type { Message, PubSub } from '@libp2p/interface'
-
-const topic = 'foo'
-
-function shouldNotHappen (): void {
-  expect.fail()
-}
-
-export default (common: TestSetup<PubSub, PubSubArgs>): void => {
-  describe('pubsub with two nodes', () => {
-    let psA: PubSub
-    let psB: PubSub
-    let componentsA: PubSubComponents
-    let componentsB: PubSubComponents
-
-    // Create pubsub nodes and connect them
-    beforeEach(async () => {
-      mockNetwork.reset()
-
-      componentsA = await createComponents()
-      componentsB = await createComponents()
-
-      psA = componentsA.pubsub = await common.setup({
-        components: componentsA,
-        init: {
-          emitSelf: true
-        }
-      })
-      psB = componentsB.pubsub = await common.setup({
-        components: componentsB,
-        init: {
-          emitSelf: false
-        }
-      })
-
-      // Start pubsub and connect nodes
-      await start(...Object.values(componentsA), ...Object.values(componentsB))
-
-      expect(psA.getPeers()).to.be.empty()
-      expect(psB.getPeers()).to.be.empty()
-
-      await componentsA.connectionManager.openConnection(componentsB.peerId)
-
-      // Wait for peers to be ready in pubsub
-      await pWaitFor(() => psA.getPeers().length === 1 && psB.getPeers().length === 1)
-    })
-
-    afterEach(async () => {
-      sinon.restore()
-      await stop(...Object.values(componentsA), ...Object.values(componentsB))
-      await common.teardown()
-      mockNetwork.reset()
-    })
-
-    it('Subscribe to a topic in nodeA', async () => {
-      const defer = pDefer()
-
-      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([componentsA.peerId.toString()])
-        expect(changedPeerId.toString()).to.equal(psB.getPeers()[0].toString())
-        expect(changedSubs).to.have.lengthOf(1)
-        expect(changedSubs[0].topic).to.equal(topic)
-        expect(changedSubs[0].subscribe).to.equal(true)
-        defer.resolve()
-      }, {
-        once: true
-      })
-      psA.subscribe(topic)
-
-      return defer.promise
-    })
-
-    it('Publish to a topic in nodeA', async () => {
-      const defer = pDefer()
-
-      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
-      })
-
-      psA.subscribe(topic)
-      psB.subscribe(topic)
-
-      await Promise.all([
-        waitForSubscriptionUpdate(psA, componentsB.peerId),
-        waitForSubscriptionUpdate(psB, componentsA.peerId)
-      ])
-
-      await psA.publish(topic, uint8ArrayFromString('hey'))
-
-      return defer.promise
-    })
-
-    it('Publish to a topic in nodeB', async () => {
-      const defer = pDefer()
-
-      psA.addEventListener('message', (evt) => {
-        if (evt.detail.topic !== topic) {
-          return
-        }
-
-        const msg = evt.detail
-        psA.addEventListener('message', (evt) => {
-          if (evt.detail.topic === topic) {
-            shouldNotHappen()
-          }
-        }, {
-          once: true
-        })
-        expect(uint8ArrayToString(msg.data)).to.equal('banana')
-
-        setTimeout(() => {
-          psA.removeEventListener('message')
-          psB.removeEventListener('message')
-
-          defer.resolve()
-        }, 100)
-      }, {
-        once: true
-      })
-
-      psB.addEventListener('message', shouldNotHappen)
-
-      psA.subscribe(topic)
-      psB.subscribe(topic)
-
-      await Promise.all([
-        waitForSubscriptionUpdate(psA, componentsB.peerId),
-        waitForSubscriptionUpdate(psB, componentsA.peerId)
-      ])
-
-      await psB.publish(topic, uint8ArrayFromString('banana'))
-
-      return defer.promise
-    })
-
-    it('validate topic message', async () => {
-      const defer = pDefer()
-
-      psA.subscribe(topic)
-
-      psB.topicValidators.set(topic, (peer, message) => {
-        if (!peer.equals(componentsA.peerId)) {
-          defer.reject(new Error('Invalid peer id in topic validator fn'))
-          return TopicValidatorResult.Reject
-        }
-
-        if (uint8ArrayToString(message.data) !== 'hey') {
-          defer.reject(new Error('Invalid message in topic validator fn'))
-          return TopicValidatorResult.Reject
-        }
-
-        defer.resolve()
-        return TopicValidatorResult.Accept
-      })
-      psB.subscribe(topic)
-
-      await Promise.all([
-        waitForSubscriptionUpdate(psA, componentsB.peerId),
-        waitForSubscriptionUpdate(psB, componentsA.peerId)
-      ])
-
-      await psA.publish(topic, uint8ArrayFromString('hey'))
-
-      return defer.promise
-    })
-
-    it('Publish 10 msg to a topic in nodeB', async () => {
-      const defer = pDefer()
-      let counter = 0
-
-      psB.addEventListener('message', shouldNotHappen)
-      psA.addEventListener('message', receivedMsg)
-
-      function receivedMsg (evt: CustomEvent<Message>): void {
-        const msg = evt.detail
-        if (msg.type === 'unsigned') {
-          expect(uint8ArrayToString(msg.data)).to.equal('banana')
-          expect(msg.topic).to.be.equal(topic)
-        } else {
-          expect(uint8ArrayToString(msg.data)).to.equal('banana')
-          expect(msg.from.toString()).to.equal(componentsB.peerId.toString())
-          expect(msg.sequenceNumber).to.be.a('BigInt')
-          expect(msg.topic).to.be.equal(topic)
-        }
-
-        if (++counter === 10) {
-          psA.removeEventListener('message', receivedMsg)
-          psB.removeEventListener('message', shouldNotHappen)
-
-          defer.resolve()
-        }
-      }
-
-      psA.subscribe(topic)
-      psB.subscribe(topic)
-
-      await Promise.all([
-        waitForSubscriptionUpdate(psA, componentsB.peerId),
-        waitForSubscriptionUpdate(psB, componentsA.peerId)
-      ])
-
-      await Promise.all(
-        Array.from({ length: 10 }, async (_, i) => {
-          await psB.publish(topic, uint8ArrayFromString('banana'))
-        })
-      )
-
-      return defer.promise
-    })
-
-    it('Unsubscribe from topic in nodeA', async () => {
-      const defer = pDefer()
-      let callCount = 0
-
-      psB.addEventListener('subscription-change', (evt) => {
-        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.toString()).to.equal(psB.getPeers()[0].toString())
-          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.toString()).to.equal(psB.getPeers()[0].toString())
-          expect(changedSubs).to.have.lengthOf(1)
-          expect(changedSubs[0].topic).to.equal(topic)
-          expect(changedSubs[0].subscribe).to.equal(false)
-
-          defer.resolve()
-        }
-      })
-
-      psA.subscribe(topic)
-      expect(psA.getTopics()).to.not.be.empty()
-
-      psA.unsubscribe(topic)
-      expect(psA.getTopics()).to.be.empty()
-
-      return defer.promise
-    })
-  })
-}