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

package/src/pubsub/two-nodes.ts

@@ -0,0 +1,273 @@
+/* eslint max-nested-callbacks: ["error", 6] */
+import { TopicValidatorResult } from '@libp2p/interface/pubsub'
+import { start, stop } from '@libp2p/interface/startable'
+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/pubsub'
+
+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).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)
+        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).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()
+        }
+      })
+
+      psA.subscribe(topic)
+      expect(psA.getTopics()).to.not.be.empty()
+
+      psA.unsubscribe(topic)
+      expect(psA.getTopics()).to.be.empty()
+
+      return defer.promise
+    })
+  })
+}

package/src/pubsub/utils.ts

@@ -0,0 +1,29 @@
+import { EventEmitter } from '@libp2p/interface/events'
+import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+import { pEvent } from 'p-event'
+import pWaitFor from 'p-wait-for'
+import { mockConnectionManager, mockRegistrar, mockNetwork } from '../mocks/index.js'
+import type { MockNetworkComponents } from '../mocks/index.js'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PubSub, SubscriptionChangeData } from '@libp2p/interface/pubsub'
+
+export async function waitForSubscriptionUpdate (a: PubSub, b: PeerId): Promise<void> {
+  await pWaitFor(async () => {
+    const event = await pEvent<'subscription-change', CustomEvent<SubscriptionChangeData>>(a, 'subscription-change')
+
+    return event.detail.peerId.equals(b)
+  })
+}
+
+export async function createComponents (): Promise<MockNetworkComponents> {
+  const components: any = {
+    peerId: await createEd25519PeerId(),
+    registrar: mockRegistrar(),
+    events: new EventEmitter()
+  }
+  components.connectionManager = mockConnectionManager(components)
+
+  mockNetwork.addNode(components)
+
+  return components
+}

package/src/stream-muxer/base-test.ts

@@ -0,0 +1,196 @@
+import { expect } from 'aegir/chai'
+import all from 'it-all'
+import drain from 'it-drain'
+import map from 'it-map'
+import { duplexPair } from 'it-pair/duplex'
+import { pipe } from 'it-pipe'
+import defer from 'p-defer'
+import { Uint8ArrayList } from 'uint8arraylist'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { isValidTick } from '../is-valid-tick.js'
+import type { TestSetup } from '../index.js'
+import type { Stream } from '@libp2p/interface/connection'
+import type { StreamMuxerFactory } from '@libp2p/interface/stream-muxer'
+import type { Source, Duplex } from 'it-stream-types'
+import type { DeferredPromise } from 'p-defer'
+
+async function drainAndClose (stream: Duplex<any>): Promise<void> {
+  await pipe([], stream, drain)
+}
+
+export default (common: TestSetup<StreamMuxerFactory>): void => {
+  describe('base', () => {
+    it('Open a stream from the dialer', async () => {
+      const p = duplexPair<Uint8Array>()
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer({ direction: 'outbound' })
+      const onStreamPromise: DeferredPromise<Stream> = defer()
+      const onStreamEndPromise: DeferredPromise<Stream> = defer()
+
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer({
+        direction: 'inbound',
+        onIncomingStream: (stream) => {
+          onStreamPromise.resolve(stream)
+        },
+        onStreamEnd: (stream) => {
+          onStreamEndPromise.resolve(stream)
+        }
+      })
+
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
+
+      const conn = await dialer.newStream()
+      expect(dialer.streams).to.include(conn)
+      expect(isValidTick(conn.timeline.open)).to.equal(true)
+
+      void drainAndClose(conn)
+
+      const stream = await onStreamPromise.promise
+      expect(isValidTick(stream.timeline.open)).to.equal(true)
+      // Make sure the stream is being tracked
+      expect(listener.streams).to.include(stream)
+
+      void drainAndClose(stream)
+
+      // Make sure stream is closed properly
+      const endedStream = await onStreamEndPromise.promise
+      expect(listener.streams).to.not.include(endedStream)
+
+      if (endedStream.timeline.close == null) {
+        throw new Error('timeline had no close time')
+      }
+
+      // Make sure the stream is removed from tracking
+      expect(isValidTick(endedStream.timeline.close)).to.equal(true)
+
+      await drainAndClose(dialer)
+      await drainAndClose(listener)
+
+      // ensure we have no streams left
+      expect(dialer.streams).to.have.length(0)
+      expect(listener.streams).to.have.length(0)
+    })
+
+    it('Open a stream from the listener', async () => {
+      const p = duplexPair<Uint8Array>()
+      const onStreamPromise: DeferredPromise<Stream> = defer()
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer({
+        direction: 'outbound',
+        onIncomingStream: (stream: Stream) => {
+          onStreamPromise.resolve(stream)
+        }
+      })
+
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer({ direction: 'inbound' })
+
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
+
+      const conn = await listener.newStream()
+
+      void drainAndClose(conn)
+
+      const stream = await onStreamPromise.promise
+      expect(isValidTick(stream.timeline.open)).to.equal(true)
+      expect(listener.streams).to.include(conn)
+      expect(isValidTick(conn.timeline.open)).to.equal(true)
+      void drainAndClose(stream)
+
+      await drainAndClose(dialer)
+      await drainAndClose(listener)
+    })
+
+    it('Open a stream on both sides', async () => {
+      const p = duplexPair<Uint8Array>()
+      const onDialerStreamPromise: DeferredPromise<Stream> = defer()
+      const onListenerStreamPromise: DeferredPromise<Stream> = defer()
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer({
+        direction: 'outbound',
+        onIncomingStream: (stream) => {
+          onDialerStreamPromise.resolve(stream)
+        }
+      })
+
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer({
+        direction: 'inbound',
+        onIncomingStream: (stream) => {
+          onListenerStreamPromise.resolve(stream)
+        }
+      })
+
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
+
+      const dialerInitiatorStream = await dialer.newStream()
+      const listenerInitiatorStream = await listener.newStream()
+
+      await Promise.all([
+        drainAndClose(dialerInitiatorStream),
+        drainAndClose(listenerInitiatorStream),
+        onDialerStreamPromise.promise.then(async stream => { await drainAndClose(stream) }),
+        onListenerStreamPromise.promise.then(async stream => { await drainAndClose(stream) })
+      ])
+
+      await Promise.all([
+        drainAndClose(dialer),
+        drainAndClose(listener)
+      ])
+    })
+
+    it('Open a stream on one side, write, open a stream on the other side', async () => {
+      const toString = (source: Source<Uint8ArrayList>): AsyncGenerator<string> => map(source, (u) => uint8ArrayToString(u.subarray()))
+      const p = duplexPair<Uint8Array>()
+      const onDialerStreamPromise: DeferredPromise<Stream> = defer()
+      const onListenerStreamPromise: DeferredPromise<Stream> = defer()
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer({
+        direction: 'outbound',
+        onIncomingStream: (stream) => {
+          onDialerStreamPromise.resolve(stream)
+        }
+      })
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer({
+        direction: 'inbound',
+        onIncomingStream: (stream) => {
+          onListenerStreamPromise.resolve(stream)
+        }
+      })
+
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
+
+      const dialerConn = await dialer.newStream()
+      const listenerConn = await listener.newStream()
+
+      void pipe([new Uint8ArrayList(uint8ArrayFromString('hey'))], dialerConn)
+      void pipe([new Uint8ArrayList(uint8ArrayFromString('hello'))], listenerConn)
+
+      const [
+        dialerStream,
+        listenerStream
+      ] = await Promise.all([
+        onDialerStreamPromise.promise,
+        onListenerStreamPromise.promise
+      ])
+
+      const [
+        listenerChunks,
+        dialerChunks
+      ] = await Promise.all([
+        pipe(listenerStream, toString, async (source) => all(source)),
+        pipe(dialerStream, toString, async (source) => all(source))
+      ])
+
+      expect(listenerChunks).to.be.eql(['hey'])
+      expect(dialerChunks).to.be.eql(['hello'])
+    })
+  })
+}