@libp2p/interface-compliance-tests 3.0.7-ea8a0637 → 3.0.7-eabf6f36

package/src/mocks/upgrader.ts

@@ -0,0 +1,49 @@
+import { mockConnection } from './connection.js'
+import type { Libp2pEvents } from '@libp2p/interface'
+import type { Connection, MultiaddrConnection } from '@libp2p/interface/connection'
+import type { EventEmitter } from '@libp2p/interface/events'
+import type { Upgrader, UpgraderOptions } from '@libp2p/interface/transport'
+import type { Registrar } from '@libp2p/interface-internal/registrar'
+
+export interface MockUpgraderInit {
+  registrar?: Registrar
+  events?: EventEmitter<Libp2pEvents>
+}
+
+class MockUpgrader implements Upgrader {
+  private readonly registrar?: Registrar
+  private readonly events?: EventEmitter<Libp2pEvents>
+
+  constructor (init: MockUpgraderInit) {
+    this.registrar = init.registrar
+    this.events = init.events
+  }
+
+  async upgradeOutbound (multiaddrConnection: MultiaddrConnection, opts: UpgraderOptions = {}): Promise<Connection> {
+    const connection = mockConnection(multiaddrConnection, {
+      direction: 'outbound',
+      registrar: this.registrar,
+      ...opts
+    })
+
+    this.events?.safeDispatchEvent('connection:open', { detail: connection })
+
+    return connection
+  }
+
+  async upgradeInbound (multiaddrConnection: MultiaddrConnection, opts: UpgraderOptions = {}): Promise<Connection> {
+    const connection = mockConnection(multiaddrConnection, {
+      direction: 'inbound',
+      registrar: this.registrar,
+      ...opts
+    })
+
+    this.events?.safeDispatchEvent('connection:open', { detail: connection })
+
+    return connection
+  }
+}
+
+export function mockUpgrader (init: MockUpgraderInit = {}): Upgrader {
+  return new MockUpgrader(init)
+}

package/src/peer-discovery/index.ts

@@ -0,0 +1,90 @@
+import { start, stop } from '@libp2p/interface/startable'
+import { isMultiaddr } from '@multiformats/multiaddr'
+import { expect } from 'aegir/chai'
+import delay from 'delay'
+import pDefer from 'p-defer'
+import type { TestSetup } from '../index.js'
+import type { PeerDiscovery } from '@libp2p/interface/peer-discovery'
+
+export default (common: TestSetup<PeerDiscovery>): void => {
+  describe('interface-peer-discovery compliance tests', () => {
+    let discovery: PeerDiscovery
+
+    beforeEach(async () => {
+      discovery = await common.setup()
+    })
+
+    afterEach('ensure discovery was stopped', async () => {
+      await stop(discovery)
+
+      await common.teardown()
+    })
+
+    it('can start the service', async () => {
+      await start(discovery)
+    })
+
+    it('can start and stop the service', async () => {
+      await start(discovery)
+      await stop(discovery)
+    })
+
+    it('should not fail to stop the service if it was not started', async () => {
+      await stop(discovery)
+    })
+
+    it('should not fail to start the service if it is already started', async () => {
+      await start(discovery)
+      await start(discovery)
+    })
+
+    it('should emit a peer event after start', async () => {
+      const defer = pDefer()
+
+      discovery.addEventListener('peer', (evt) => {
+        const { id, multiaddrs } = evt.detail
+        expect(id).to.exist()
+        expect(id)
+          .to.have.property('type')
+          .that.is.oneOf(['RSA', 'Ed25519', 'secp256k1'])
+        expect(multiaddrs).to.exist()
+
+        multiaddrs.forEach((m) => expect(isMultiaddr(m)).to.eql(true))
+
+        defer.resolve()
+      })
+
+      await start(discovery)
+
+      await defer.promise
+    })
+
+    it('should not receive a peer event before start', async () => {
+      discovery.addEventListener('peer', () => {
+        throw new Error('should not receive a peer event before start')
+      })
+
+      await delay(2000)
+    })
+
+    it('should not receive a peer event after stop', async () => {
+      const deferStart = pDefer()
+
+      discovery.addEventListener('peer', () => {
+        deferStart.resolve()
+      })
+
+      await start(discovery)
+
+      await deferStart.promise
+
+      await stop(discovery)
+
+      discovery.addEventListener('peer', () => {
+        throw new Error('should not receive a peer event after stop')
+      })
+
+      await delay(2000)
+    })
+  })
+}

package/src/pubsub/api.ts

@@ -0,0 +1,114 @@
+import { isStartable, start, stop } from '@libp2p/interface/startable'
+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 { mockNetwork } from '../mocks/index.js'
+import { createComponents } from './utils.js'
+import type { PubSubArgs, PubSubComponents } from './index.js'
+import type { TestSetup } from '../index.js'
+import type { PubSub } from '@libp2p/interface/pubsub'
+
+const topic = 'foo'
+const data = uint8ArrayFromString('bar')
+
+export default (common: TestSetup<PubSub, PubSubArgs>): void => {
+  describe('pubsub api', () => {
+    let pubsub: PubSub
+    let components: PubSubComponents
+
+    // Create pubsub router
+    beforeEach(async () => {
+      mockNetwork.reset()
+      components = await createComponents()
+
+      pubsub = components.pubsub = await common.setup({
+        components,
+        init: {
+          emitSelf: true
+        }
+      })
+    })
+
+    afterEach(async () => {
+      sinon.restore()
+      await stop(...Object.values(components))
+      await common.teardown()
+      mockNetwork.reset()
+    })
+
+    it('can start correctly', async () => {
+      if (!isStartable(pubsub)) {
+        return
+      }
+
+      sinon.spy(components.registrar, 'register')
+
+      await start(...Object.values(components))
+
+      expect(pubsub.isStarted()).to.equal(true)
+      expect(components.registrar.register).to.have.property('callCount', 1)
+    })
+
+    it('can stop correctly', async () => {
+      if (!isStartable(pubsub)) {
+        return
+      }
+
+      sinon.spy(components.registrar, 'unregister')
+
+      await start(...Object.values(components))
+      await stop(...Object.values(components))
+
+      expect(pubsub.isStarted()).to.equal(false)
+      expect(components.registrar.unregister).to.have.property('callCount', 1)
+    })
+
+    it('can subscribe and unsubscribe correctly', async () => {
+      const handler = (): void => {
+        throw new Error('a message should not be received')
+      }
+
+      await start(...Object.values(components))
+      pubsub.subscribe(topic)
+      pubsub.addEventListener('message', handler)
+
+      await pWaitFor(() => {
+        const topics = pubsub.getTopics()
+        return topics.length === 1 && topics[0] === topic
+      })
+
+      pubsub.removeEventListener('message', handler)
+      pubsub.unsubscribe(topic)
+
+      await pWaitFor(() => pubsub.getTopics().length === 0)
+
+      // Publish to guarantee the handler is not called
+      await pubsub.publish(topic, data)
+
+      // handlers are called async
+      await delay(100)
+
+      await stop(...Object.values(components))
+    })
+
+    it('can subscribe and publish correctly', async () => {
+      const defer = pDefer()
+
+      await start(...Object.values(components))
+
+      pubsub.subscribe(topic)
+      pubsub.addEventListener('message', (evt) => {
+        expect(evt).to.have.nested.property('detail.topic', topic)
+        expect(evt).to.have.deep.nested.property('detail.data', data)
+        defer.resolve()
+      })
+      await pubsub.publish(topic, data)
+      await defer.promise
+
+      await stop(...Object.values(components))
+    })
+  })
+}

package/src/pubsub/connection-handlers.ts

@@ -0,0 +1,413 @@
+import { start, stop } from '@libp2p/interface/startable'
+import { expect } from 'aegir/chai'
+import pDefer from 'p-defer'
+import { pEvent } from 'p-event'
+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 } from './utils.js'
+import type { PubSubArgs } from './index.js'
+import type { TestSetup } from '../index.js'
+import type { MockNetworkComponents } from '../mocks/index.js'
+import type { Message, PubSub } from '@libp2p/interface/pubsub'
+
+export default (common: TestSetup<PubSub, PubSubArgs>): void => {
+  describe('pubsub connection handlers', () => {
+    let psA: PubSub
+    let psB: PubSub
+    let componentsA: MockNetworkComponents
+    let componentsB: MockNetworkComponents
+
+    describe('nodes send state on connection', () => {
+      // 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: {}
+        })
+
+        psB = componentsB.pubsub = await common.setup({
+          components: componentsB,
+          init: {}
+        })
+
+        // Start pubsub
+        await start(...Object.values(componentsA), ...Object.values(componentsB))
+
+        expect(psA.getPeers()).to.be.empty()
+        expect(psB.getPeers()).to.be.empty()
+
+        // Make subscriptions prior to nodes connected
+        psA.subscribe('Za')
+        psB.subscribe('Zb')
+
+        expect(psA.getPeers()).to.be.empty()
+        expect(psA.getTopics()).to.deep.equal(['Za'])
+        expect(psB.getPeers()).to.be.empty()
+        expect(psB.getTopics()).to.deep.equal(['Zb'])
+      })
+
+      afterEach(async () => {
+        sinon.restore()
+        await stop(...Object.values(componentsA), ...Object.values(componentsB))
+        await common.teardown()
+        mockNetwork.reset()
+      })
+
+      it('existing subscriptions are sent upon peer connection', async function () {
+        const subscriptionsChanged = Promise.all([
+          pEvent(psA, 'subscription-change'),
+          pEvent(psB, 'subscription-change')
+        ])
+
+        await componentsA.connectionManager.openConnection(componentsB.peerId)
+
+        await subscriptionsChanged
+
+        expect(psA.getPeers()).to.have.lengthOf(1)
+        expect(psB.getPeers()).to.have.lengthOf(1)
+
+        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([componentsB.peerId.toString()])
+        expect(psB.getSubscribers('Za').map(p => p.toString())).to.deep.equal([componentsA.peerId.toString()])
+      })
+    })
+
+    describe('pubsub started before connect', () => {
+      let psA: PubSub
+      let psB: PubSub
+      let componentsA: MockNetworkComponents
+      let componentsB: MockNetworkComponents
+
+      // Create pubsub nodes and start them
+      beforeEach(async () => {
+        mockNetwork.reset()
+        componentsA = await createComponents()
+        componentsB = await createComponents()
+
+        psA = componentsA.pubsub = await common.setup({
+          components: componentsA,
+          init: {}
+        })
+        psB = componentsB.pubsub = await common.setup({
+          components: componentsB,
+          init: {}
+        })
+
+        await start(...Object.values(componentsA), ...Object.values(componentsB))
+      })
+
+      afterEach(async () => {
+        sinon.restore()
+        await stop(...Object.values(componentsA), ...Object.values(componentsB))
+        await common.teardown()
+        mockNetwork.reset()
+      })
+
+      it('should get notified of connected peers on dial', async () => {
+        await componentsA.connectionManager.openConnection(componentsB.peerId)
+
+        return Promise.all([
+          pWaitFor(() => psA.getPeers().length === 1),
+          pWaitFor(() => psB.getPeers().length === 1)
+        ])
+      })
+
+      it('should receive pubsub messages', async () => {
+        const defer = pDefer()
+        const topic = 'test-topic'
+        const data = uint8ArrayFromString('hey!')
+
+        await componentsA.connectionManager.openConnection(componentsB.peerId)
+
+        let subscribedTopics = psA.getTopics()
+        expect(subscribedTopics).to.not.include(topic)
+
+        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)
+
+        subscribedTopics = psA.getTopics()
+        expect(subscribedTopics).to.include(topic)
+
+        // wait for psB to know about psA subscription
+        await pWaitFor(() => {
+          const subscribedPeers = psB.getSubscribers(topic)
+          return subscribedPeers.map(p => p.toString()).includes(componentsA.peerId.toString()) // eslint-disable-line max-nested-callbacks
+        })
+        await psB.publish(topic, data)
+
+        await defer.promise
+      })
+    })
+
+    describe('pubsub started after connect', () => {
+      let psA: PubSub
+      let psB: PubSub
+      let componentsA: MockNetworkComponents
+      let componentsB: MockNetworkComponents
+
+      // Create pubsub nodes
+      beforeEach(async () => {
+        mockNetwork.reset()
+        componentsA = await createComponents()
+        componentsB = await createComponents()
+
+        psA = componentsA.pubsub = await common.setup({
+          components: componentsA,
+          init: {}
+        })
+        psB = componentsB.pubsub = await common.setup({
+          components: componentsB,
+          init: {}
+        })
+      })
+
+      afterEach(async () => {
+        sinon.restore()
+        await stop(...Object.values(componentsA), ...Object.values(componentsB))
+        await common.teardown()
+        mockNetwork.reset()
+      })
+
+      it('should get notified of connected peers after starting', async () => {
+        await start(...Object.values(componentsA), ...Object.values(componentsB))
+
+        await componentsA.connectionManager.openConnection(componentsB.peerId)
+
+        return Promise.all([
+          pWaitFor(() => psA.getPeers().length === 1),
+          pWaitFor(() => psB.getPeers().length === 1)
+        ])
+      })
+
+      it('should receive pubsub messages', async () => {
+        const defer = pDefer()
+        const topic = 'test-topic'
+        const data = uint8ArrayFromString('hey!')
+
+        await start(...Object.values(componentsA), ...Object.values(componentsB))
+
+        await componentsA.connectionManager.openConnection(componentsB.peerId)
+
+        await Promise.all([
+          pWaitFor(() => psA.getPeers().length === 1),
+          pWaitFor(() => psB.getPeers().length === 1)
+        ])
+
+        let subscribedTopics = psA.getTopics()
+        expect(subscribedTopics).to.not.include(topic)
+
+        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)
+
+        subscribedTopics = psA.getTopics()
+        expect(subscribedTopics).to.include(topic)
+
+        // wait for psB to know about psA subscription
+        await pWaitFor(() => {
+          const subscribedPeers = psB.getSubscribers(topic)
+          return subscribedPeers.map(p => p.toString()).includes(componentsA.peerId.toString()) // eslint-disable-line max-nested-callbacks
+        })
+        await psB.publish(topic, data)
+
+        await defer.promise
+      })
+    })
+
+    describe('pubsub with intermittent connections', () => {
+      let psA: PubSub
+      let psB: PubSub
+      let componentsA: MockNetworkComponents
+      let componentsB: MockNetworkComponents
+
+      // Create pubsub nodes and start them
+      beforeEach(async () => {
+        mockNetwork.reset()
+        componentsA = await createComponents()
+        componentsB = await createComponents()
+
+        psA = componentsA.pubsub = await common.setup({
+          components: componentsA,
+          init: {}
+        })
+        psB = componentsB.pubsub = await common.setup({
+          components: componentsB,
+          init: {}
+        })
+
+        await start(...Object.values(componentsA), ...Object.values(componentsB))
+      })
+
+      afterEach(async () => {
+        sinon.restore()
+        await stop(...Object.values(componentsA), ...Object.values(componentsB))
+        await common.teardown()
+        mockNetwork.reset()
+      })
+
+      it.skip('should receive pubsub messages after a node restart', async function () {
+        const topic = 'test-topic'
+        const data = uint8ArrayFromString('hey!')
+
+        let counter = 0
+        const defer1 = pDefer()
+        const defer2 = pDefer()
+
+        await componentsA.connectionManager.openConnection(componentsB.peerId)
+
+        let subscribedTopics = psA.getTopics()
+        expect(subscribedTopics).to.not.include(topic)
+
+        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)
+
+        subscribedTopics = psA.getTopics()
+        expect(subscribedTopics).to.include(topic)
+
+        // wait for psB to know about psA subscription
+        await pWaitFor(() => {
+          const subscribedPeers = psB.getSubscribers(topic)
+          return subscribedPeers.map(p => p.toString()).includes(componentsA.peerId.toString()) // eslint-disable-line max-nested-callbacks
+        })
+        await psB.publish(topic, data)
+
+        await defer1.promise
+
+        await stop(psB)
+        await pWaitFor(() => {
+          // @ts-expect-error protected fields
+          const aHasConnectionToB = psA._libp2p.connectionManager.get(psB.peerId)
+          // @ts-expect-error protected fields
+          const bHasConnectionToA = psB._libp2p.connectionManager.get(psA.peerId)
+
+          return aHasConnectionToB != null && bHasConnectionToA != null
+        })
+        await start(psB)
+
+        await componentsA.connectionManager.openConnection(componentsB.peerId)
+
+        // wait for remoteLibp2p to know about libp2p subscription
+        await pWaitFor(() => {
+          const subscribedPeers = psB.getSubscribers(topic)
+          return subscribedPeers.toString().includes(componentsA.peerId.toString())
+        })
+
+        await psB.publish(topic, data)
+
+        await defer2.promise
+      })
+
+      it.skip('should handle quick reconnects with a delayed disconnect', async () => {
+        // Subscribe on both
+        let aReceivedFirstMessageFromB = false
+        let aReceivedSecondMessageFromB = false
+        let bReceivedFirstMessageFromA = false
+        let bReceivedSecondMessageFromA = false
+        const topic = 'reconnect-channel'
+
+        const handlerSpyA = (evt: CustomEvent<Message>): void => {
+          if (evt.detail.topic !== topic) {
+            return
+          }
+
+          const message = evt.detail
+          const data = uint8ArrayToString(message.data)
+
+          if (data === 'message-from-b-1') {
+            aReceivedFirstMessageFromB = true
+          }
+
+          if (data === 'message-from-b-2') {
+            aReceivedSecondMessageFromB = true
+          }
+        }
+        const handlerSpyB = (evt: CustomEvent<Message>): void => {
+          if (evt.detail.topic !== topic) {
+            return
+          }
+
+          const message = evt.detail
+          const data = uint8ArrayToString(message.data)
+
+          if (data === 'message-from-a-1') {
+            bReceivedFirstMessageFromA = true
+          }
+
+          if (data === 'message-from-a-2') {
+            bReceivedSecondMessageFromA = true
+          }
+        }
+
+        psA.addEventListener('message', handlerSpyA)
+        psB.addEventListener('message', handlerSpyB)
+        psA.subscribe(topic)
+        psB.subscribe(topic)
+
+        // Create two connections to the remote peer
+        // @ts-expect-error protected fields
+        const originalConnection = await psA._libp2p.dialer.connectToPeer(psB.peerId)
+
+        // second connection
+        await componentsA.connectionManager.openConnection(componentsB.peerId)
+
+        // Wait for subscriptions to occur
+        await pWaitFor(() => {
+          return psA.getSubscribers(topic).map(p => p.toString()).includes(componentsB.peerId.toString()) &&
+            psB.getSubscribers(topic).map(p => p.toString()).includes(componentsA.peerId.toString())
+        })
+
+        // Verify messages go both ways
+        await psA.publish(topic, uint8ArrayFromString('message-from-a-1'))
+        await psB.publish(topic, uint8ArrayFromString('message-from-b-1'))
+        await pWaitFor(() => {
+          return aReceivedFirstMessageFromB && bReceivedFirstMessageFromA
+        })
+
+        // Disconnect the first connection (this acts as a delayed reconnect)
+        // @ts-expect-error protected fields
+        const psAConnUpdateSpy = sinon.spy(psA._libp2p.connectionManager.connections, 'set')
+
+        await originalConnection.close()
+        await pWaitFor(() => psAConnUpdateSpy.callCount === 1)
+
+        // Verify messages go both ways after the disconnect
+        await psA.publish(topic, uint8ArrayFromString('message-from-a-2'))
+        await psB.publish(topic, uint8ArrayFromString('message-from-b-2'))
+        await pWaitFor(() => {
+          return aReceivedSecondMessageFromB && bReceivedSecondMessageFromA
+        })
+      })
+    })
+  })
+}