@libp2p/interface-compliance-tests 0.0.0 → 1.0.2

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

@@ -0,0 +1,155 @@
+import { expect } from 'aegir/utils/chai.js'
+// @ts-expect-error no types
+import pair from 'it-pair/duplex.js'
+import { pipe } from 'it-pipe'
+import { collect, map, consume } from 'streaming-iterables'
+import defer from 'p-defer'
+import type { DeferredPromise } from 'p-defer'
+import type { TestSetup } from '../index.js'
+import type { Muxer, MuxerOptions, MuxedStream } from '@libp2p/interfaces/stream-muxer'
+import { isValidTick } from '../transport/utils/index.js'
+
+function close (stream: MuxedStream) {
+  return pipe([], stream, consume)
+}
+
+export default (common: TestSetup<Muxer, MuxerOptions>) => {
+  describe('base', () => {
+    it('Open a stream from the dialer', async () => {
+      const p = pair()
+      const dialer = await common.setup()
+      const onStreamPromise: DeferredPromise<MuxedStream> = defer()
+      const onStreamEndPromise: DeferredPromise<MuxedStream> = defer()
+
+      const listener = await common.setup({
+        onStream: stream => {
+          onStreamPromise.resolve(stream)
+        },
+        onStreamEnd: stream => {
+          onStreamEndPromise.resolve(stream)
+        }
+      })
+
+      pipe(p[0], dialer, p[0])
+      pipe(p[1], listener, p[1])
+
+      const conn = dialer.newStream()
+      expect(dialer.streams).to.include(conn)
+      expect(isValidTick(conn.timeline.open)).to.equal(true)
+
+      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)
+      close(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 close(conn)
+
+      // 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 = pair()
+      const onStreamPromise: DeferredPromise<MuxedStream> = defer()
+      const dialer = await common.setup({
+        onStream: stream => {
+          onStreamPromise.resolve(stream)
+        }
+      })
+
+      const listener = await common.setup()
+
+      pipe(p[0], dialer, p[0])
+      pipe(p[1], listener, p[1])
+
+      const conn = listener.newStream()
+
+      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)
+      await close(stream)
+
+      await close(conn)
+    })
+
+    it('Open a stream on both sides', async () => {
+      const p = pair()
+      const onDialerStreamPromise: DeferredPromise<MuxedStream> = defer()
+      const onListenerStreamPromise: DeferredPromise<MuxedStream> = defer()
+      const dialer = await common.setup({
+        onStream: stream => {
+          onDialerStreamPromise.resolve(stream)
+        }
+      })
+      const listener = await common.setup({
+        onStream: stream => {
+          onListenerStreamPromise.resolve(stream)
+        }
+      })
+
+      pipe(p[0], dialer, p[0])
+      pipe(p[1], listener, p[1])
+
+      const listenerConn = listener.newStream()
+      const dialerConn = dialer.newStream()
+
+      const dialerStream = await onDialerStreamPromise.promise
+      const listenerStream = await onListenerStreamPromise.promise
+
+      await close(dialerStream)
+      await close(listenerStream)
+
+      await close(dialerConn)
+      await close(listenerConn)
+    })
+
+    it('Open a stream on one side, write, open a stream on the other side', async () => {
+      const toString = map((c: string) => c.slice().toString())
+      const p = pair()
+      const onDialerStreamPromise: DeferredPromise<MuxedStream> = defer()
+      const onListenerStreamPromise: DeferredPromise<MuxedStream> = defer()
+      const dialer = await common.setup({
+        onStream: stream => {
+          onDialerStreamPromise.resolve(stream)
+        }
+      })
+      const listener = await common.setup({
+        onStream: stream => {
+          onListenerStreamPromise.resolve(stream)
+        }
+      })
+
+      pipe(p[0], dialer, p[0])
+      pipe(p[1], listener, p[1])
+
+      const dialerConn = dialer.newStream()
+      const listenerConn = listener.newStream()
+
+      pipe(['hey'], dialerConn)
+      pipe(['hello'], listenerConn)
+
+      const listenerStream = await onListenerStreamPromise.promise
+      const dialerStream = await onDialerStreamPromise.promise
+
+      const listenerChunks = await pipe(listenerStream, toString, collect)
+      expect(listenerChunks).to.be.eql(['hey'])
+
+      const dialerChunks = await pipe(dialerStream, toString, collect)
+      expect(dialerChunks).to.be.eql(['hello'])
+    })
+  })
+}

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

@@ -0,0 +1,124 @@
+/* eslint max-nested-callbacks: ["error", 8] */
+// @ts-expect-error no types
+import pair from 'it-pair/duplex.js'
+import { pipe } from 'it-pipe'
+import { consume } from 'streaming-iterables'
+import { source, duplex } from 'abortable-iterator'
+import AbortController from 'abort-controller'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import type { TestSetup } from '../index.js'
+import type { Muxer, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
+import type { Connection } from '@libp2p/interfaces/connection'
+
+async function pause (ms: number) {
+  return await new Promise(resolve => setTimeout(resolve, ms))
+}
+
+function randomBuffer () {
+  return uint8ArrayFromString(Math.random().toString())
+}
+
+const infiniteRandom = {
+  [Symbol.asyncIterator]: async function * () {
+    while (true) {
+      yield randomBuffer()
+      await pause(10)
+    }
+  }
+}
+
+export default (common: TestSetup<Muxer, MuxerOptions>) => {
+  describe('close', () => {
+    it('closing underlying socket closes streams (tcp)', async () => {
+      const mockConn = (muxer: Muxer): Connection => {
+        // @ts-expect-error not all Connection methods are implemented
+        const connection: Connection = {
+          newStream: async (multicodecs) => {
+            return {
+              protocol: multicodecs[0],
+              stream: muxer.newStream(`${multicodecs[0]}`)
+            }
+          }
+        }
+
+        return connection
+      }
+
+      const mockUpgrade = async (maConn: any) => {
+        const muxer = await common.setup({
+          onStream: (stream) => {
+            pipe(stream, stream)
+          }
+        })
+        pipe(maConn, muxer, maConn)
+        return mockConn(muxer)
+      }
+
+      const [local, remote] = pair()
+      const controller = new AbortController()
+      const abortableRemote = duplex(remote, controller.signal, {
+        returnOnAbort: true
+      })
+
+      await mockUpgrade(abortableRemote)
+      const dialerConn = await mockUpgrade(local)
+
+      const s1 = await dialerConn.newStream([''])
+      const s2 = await dialerConn.newStream([''])
+
+      // close the remote in a bit
+      setTimeout(() => controller.abort(), 50)
+
+      const s1Result = pipe(infiniteRandom, s1, consume)
+      const s2Result = pipe(infiniteRandom, s2, consume)
+
+      // test is complete when all muxed streams have closed
+      await s1Result
+      await s2Result
+    })
+
+    it('closing one of the muxed streams doesn\'t close others', async () => {
+      const p = pair()
+      const dialer = await common.setup()
+
+      // Listener is echo server :)
+      const listener = await common.setup({
+        onStream: (stream) => pipe(stream, stream)
+      })
+
+      pipe(p[0], dialer, p[0])
+      pipe(p[1], listener, p[1])
+
+      const stream = dialer.newStream()
+      const streams = Array.from(Array(5), () => dialer.newStream())
+      let closed = false
+      const controllers: AbortController[] = []
+
+      const streamResults = streams.map(async stream => {
+        const controller = new AbortController()
+        controllers.push(controller)
+
+        try {
+          const abortableRand = source(infiniteRandom, controller.signal, { abortCode: 'ERR_TEST_ABORT' })
+          await pipe(abortableRand, stream, consume)
+        } catch (err: any) {
+          if (err.code !== 'ERR_TEST_ABORT') throw err
+        }
+
+        if (!closed) throw new Error('stream should not have ended yet!')
+      })
+
+      // Pause, and then send some data and close the first stream
+      await pause(50)
+      await pipe([randomBuffer()], stream, consume)
+      closed = true
+
+      // Abort all the other streams later
+      await pause(50)
+      controllers.forEach(c => c.abort())
+
+      // These should now all resolve without error
+      await Promise.all(streamResults)
+    })
+  })
+}

package/src/stream-muxer/index.ts

@@ -0,0 +1,15 @@
+import baseTest from './base-test.js'
+import closeTest from './close-test.js'
+import stressTest from './stress-test.js'
+import megaStressTest from './mega-stress-test.js'
+import type { TestSetup } from '../index.js'
+import type { Muxer } from '@libp2p/interfaces/stream-muxer'
+
+export default (common: TestSetup<Muxer>) => {
+  describe('interface-stream-muxer', () => {
+    baseTest(common)
+    closeTest(common)
+    stressTest(common)
+    megaStressTest(common)
+  })
+}

package/src/stream-muxer/mega-stress-test.ts

@@ -0,0 +1,11 @@
+import spawn from './spawner'
+import type { TestSetup } from '../index.js'
+import type { Muxer, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
+
+export default (common: TestSetup<Muxer, MuxerOptions>) => {
+  const createMuxer = async (opts?: MuxerOptions) => await common.setup(opts)
+
+  describe.skip('mega stress test', function () {
+    it('10,000 streams with 10,000 msg', async () => await spawn(createMuxer, 10000, 10000, 5000))
+  })
+}

package/src/stream-muxer/spawner.ts

@@ -0,0 +1,52 @@
+import { expect } from 'aegir/utils/chai.js'
+// @ts-expect-error no types
+import pair from 'it-pair/duplex.js'
+import { pipe } from 'it-pipe'
+import pLimit from 'p-limit'
+import { collect, consume } from 'streaming-iterables'
+import type { Muxer, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
+
+export default async (createMuxer: (options?: MuxerOptions) => Promise<Muxer>, nStreams: number, nMsg: number, limit?: number) => {
+  const [dialerSocket, listenerSocket] = pair()
+
+  const msg = 'simple msg'
+
+  const listener = await createMuxer({
+    onStream: async (stream) => {
+      await pipe(
+        stream,
+        consume
+      )
+
+      pipe([], stream)
+    }
+  })
+
+  const dialer = await createMuxer()
+
+  pipe(listenerSocket, listener, listenerSocket)
+  pipe(dialerSocket, dialer, dialerSocket)
+
+  const spawnStream = async () => {
+    const stream = dialer.newStream()
+    expect(stream).to.exist // eslint-disable-line
+
+    const res = await pipe(
+      (function * () {
+        for (let i = 0; i < nMsg; i++) {
+          yield new Promise(resolve => resolve(msg))
+        }
+      })(),
+      stream,
+      collect
+    )
+
+    expect(res).to.be.eql([])
+  }
+
+  const limiter = pLimit(limit ?? Infinity)
+
+  await Promise.all(
+    Array.from(Array(nStreams), async () => await limiter(async () => await spawnStream()))
+  )
+}

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

@@ -0,0 +1,24 @@
+import spawn from './spawner'
+import type { TestSetup } from '../index.js'
+import type { Muxer, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
+
+export default (common: TestSetup<Muxer, MuxerOptions>) => {
+  const createMuxer = async (opts?: MuxerOptions) => await common.setup(opts)
+
+  describe('stress test', () => {
+    it('1 stream with 1 msg', async () => await spawn(createMuxer, 1, 1))
+    it('1 stream with 10 msg', async () => await spawn(createMuxer, 1, 10))
+    it('1 stream with 100 msg', async () => await spawn(createMuxer, 1, 100))
+    it('10 streams with 1 msg', async () => await spawn(createMuxer, 10, 1))
+    it('10 streams with 10 msg', async () => await spawn(createMuxer, 10, 10))
+    it('10 streams with 100 msg', async () => await spawn(createMuxer, 10, 100))
+    it('100 streams with 1 msg', async () => await spawn(createMuxer, 100, 1))
+    it('100 streams with 10 msg', async () => await spawn(createMuxer, 100, 10))
+    it('100 streams with 100 msg', async () => await spawn(createMuxer, 100, 100))
+    it('1000 streams with 1 msg', async () => await spawn(createMuxer, 1000, 1))
+    it('1000 streams with 10 msg', async () => await spawn(createMuxer, 1000, 10))
+    it('1000 streams with 100 msg', async function () {
+      return await spawn(createMuxer, 1000, 100)
+    })
+  })
+}

package/src/topology/multicodec-topology.ts

@@ -0,0 +1,136 @@
+import { expect } from 'aegir/utils/chai.js'
+import sinon from 'sinon'
+import * as PeerIdFactory from '@libp2p/peer-id-factory'
+import peers from '../utils/peers.js'
+import type { TestSetup } from '../index.js'
+import type { MulticodecTopology } from '@libp2p/interfaces/topology'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+
+export default (test: TestSetup<MulticodecTopology>) => {
+  describe('multicodec topology', () => {
+    let topology: MulticodecTopology, id: PeerId
+
+    beforeEach(async () => {
+      topology = await test.setup()
+
+      id = await PeerIdFactory.createFromJSON(peers[0])
+    })
+
+    afterEach(async () => {
+      sinon.restore()
+      await test.teardown()
+    })
+
+    it('should have properties set', () => {
+      expect(topology.multicodecs).to.exist()
+      expect(topology.peers).to.exist()
+    })
+
+    it('should trigger "onDisconnect" on peer disconnected', () => {
+      // @ts-expect-error protected property
+      sinon.spy(topology, '_onDisconnect')
+      topology.disconnect(id)
+
+      expect(topology).to.have.nested.property('_onDisconnect.callCount', 1)
+    })
+
+    it('should update peers on protocol change', async () => {
+      // @ts-expect-error protected property
+      sinon.spy(topology, '_updatePeers')
+      expect(topology.peers.size).to.eql(0)
+
+      // @ts-expect-error protected property
+      const peerStore = topology._registrar.peerStore
+
+      const id2 = await PeerIdFactory.createFromJSON(peers[1])
+      peerStore.peers.set(id2.toString(), {
+        id: id2,
+        protocols: Array.from(topology.multicodecs)
+      })
+
+      peerStore.emit('change:protocols', {
+        peerId: id2,
+        protocols: Array.from(topology.multicodecs)
+      })
+
+      expect(topology).to.have.nested.property('_updatePeers.callCount', 1)
+      expect(topology.peers.size).to.eql(1)
+    })
+
+    it('should disconnect if peer no longer supports a protocol', async () => {
+      // @ts-expect-error protected property
+      sinon.spy(topology, '_onDisconnect')
+      expect(topology.peers.size).to.eql(0)
+
+      // @ts-expect-error protected property
+      const peerStore = topology._registrar.peerStore
+
+      const id2 = await PeerIdFactory.createFromJSON(peers[1])
+      peerStore.peers.set(id2.toString(), {
+        id: id2,
+        protocols: Array.from(topology.multicodecs)
+      })
+
+      peerStore.emit('change:protocols', {
+        peerId: id2,
+        protocols: Array.from(topology.multicodecs)
+      })
+
+      expect(topology.peers.size).to.eql(1)
+
+      peerStore.peers.set(id2.toString(), {
+        id: id2,
+        protocols: []
+      })
+      // Peer does not support the protocol anymore
+      peerStore.emit('change:protocols', {
+        peerId: id2,
+        protocols: []
+      })
+
+      expect(topology.peers.size).to.eql(1)
+      expect(topology).to.have.nested.property('_onDisconnect.callCount', 1)
+      // @ts-expect-error protected property
+      expect(topology._onDisconnect.calledWith(id2)).to.equal(true)
+    })
+
+    it('should trigger "onConnect" when a peer connects and has one of the topology multicodecs in its known protocols', () => {
+      // @ts-expect-error protected property
+      sinon.spy(topology, '_onConnect')
+      // @ts-expect-error protected property
+      sinon.stub(topology._registrar.peerStore.protoBook, 'get').returns(topology.multicodecs)
+      // @ts-expect-error protected property
+      topology._registrar.connectionManager.emit('peer:connect', {
+        remotePeer: id
+      })
+
+      expect(topology).to.have.nested.property('_onConnect.callCount', 1)
+    })
+
+    it('should not trigger "onConnect" when a peer connects and has none of the topology multicodecs in its known protocols', () => {
+      // @ts-expect-error protected property
+      sinon.spy(topology, '_onConnect')
+      // @ts-expect-error protected property
+      sinon.stub(topology._registrar.peerStore.protoBook, 'get').returns([])
+      // @ts-expect-error protected property
+      topology._registrar.connectionManager.emit('peer:connect', {
+        remotePeer: id
+      })
+
+      expect(topology).to.have.nested.property('_onConnect.callCount', 0)
+    })
+
+    it('should not trigger "onConnect" when a peer connects and its protocols are not known', () => {
+      // @ts-expect-error protected property
+      sinon.spy(topology, '_onConnect')
+      // @ts-expect-error protected property
+      sinon.stub(topology._registrar.peerStore.protoBook, 'get').returns(undefined)
+      // @ts-expect-error protected property
+      topology._registrar.connectionManager.emit('peer:connect', {
+        remotePeer: id
+      })
+
+      expect(topology).to.have.nested.property('_onConnect.callCount', 0)
+    })
+  })
+}

package/src/topology/topology.ts

@@ -0,0 +1,38 @@
+import { expect } from 'aegir/utils/chai.js'
+import sinon from 'sinon'
+import * as PeerIdFactory from '@libp2p/peer-id-factory'
+import peers from '../utils/peers.js'
+import type { TestSetup } from '../index.js'
+import type { Topology } from '@libp2p/interfaces/topology'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+
+export default (test: TestSetup<Topology>) => {
+  describe('topology', () => {
+    let topology: Topology, id: PeerId
+
+    beforeEach(async () => {
+      topology = await test.setup()
+
+      id = await PeerIdFactory.createFromJSON(peers[0])
+    })
+
+    afterEach(async () => {
+      sinon.restore()
+      await test.teardown()
+    })
+
+    it('should have properties set', () => {
+      expect(topology.min).to.exist()
+      expect(topology.max).to.exist()
+      expect(topology.peers).to.exist()
+    })
+
+    it('should trigger "onDisconnect" on peer disconnected', () => {
+      // @ts-expect-error protected property
+      sinon.spy(topology, '_onDisconnect')
+      topology.disconnect(id)
+
+      expect(topology).to.have.nested.property('_onDisconnect.callCount', 1)
+    })
+  })
+}

package/src/transport/dial-test.ts

@@ -0,0 +1,98 @@
+import { expect } from 'aegir/utils/chai.js'
+import { isValidTick, mockUpgrader } from './utils/index.js'
+// @ts-expect-error no types
+import goodbye from 'it-goodbye'
+import { collect } from 'streaming-iterables'
+import { pipe } from 'it-pipe'
+import AbortController from 'abort-controller'
+import { AbortError } from '@libp2p/interfaces/errors'
+import sinon from 'sinon'
+import type { TestSetup } from '../index.js'
+import type { Transport, Listener } from '@libp2p/interfaces/transport'
+import type { TransportTestFixtures, SetupArgs, Connector } from './index.js'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
+  describe('dial', () => {
+    const upgrader = mockUpgrader()
+    let addrs: Multiaddr[]
+    let transport: Transport<any, any>
+    let connector: Connector
+    let listener: Listener
+
+    before(async () => {
+      ({ addrs, transport, connector } = await common.setup({ upgrader }))
+    })
+
+    after(async () => {
+      await common.teardown()
+    })
+
+    beforeEach(async () => {
+      listener = transport.createListener({})
+      return await listener.listen(addrs[0])
+    })
+
+    afterEach(async () => {
+      sinon.restore()
+      connector.restore()
+      return await listener.close()
+    })
+
+    it('simple', async () => {
+      const upgradeSpy = sinon.spy(upgrader, 'upgradeOutbound')
+      const conn = await transport.dial(addrs[0])
+      const { stream } = await conn.newStream(['/hello'])
+      const s = goodbye({ source: ['hey'], sink: collect })
+
+      const result = await pipe(s, stream, s)
+
+      expect(upgradeSpy.callCount).to.equal(1)
+      await expect(upgradeSpy.getCall(0).returnValue).to.eventually.equal(conn)
+      expect(result.length).to.equal(1)
+      expect(result[0].toString()).to.equal('hey')
+      await conn.close()
+    })
+
+    it('can close connections', async () => {
+      const upgradeSpy = sinon.spy(upgrader, 'upgradeOutbound')
+      const conn = await transport.dial(addrs[0])
+
+      expect(upgradeSpy.callCount).to.equal(1)
+      await expect(upgradeSpy.getCall(0).returnValue).to.eventually.equal(conn)
+      await conn.close()
+      expect(isValidTick(conn.stat.timeline.close)).to.equal(true)
+    })
+
+    it('to non existent listener', async () => {
+      const upgradeSpy = sinon.spy(upgrader, 'upgradeOutbound')
+
+      await expect(transport.dial(addrs[1])).to.eventually.be.rejected()
+      expect(upgradeSpy.callCount).to.equal(0)
+    })
+
+    it('abort before dialing throws AbortError', async () => {
+      const upgradeSpy = sinon.spy(upgrader, 'upgradeOutbound')
+      const controller = new AbortController()
+      controller.abort()
+      const conn = transport.dial(addrs[0], { signal: controller.signal })
+
+      await expect(conn).to.eventually.be.rejected().with.property('code', AbortError.code)
+      expect(upgradeSpy.callCount).to.equal(0)
+    })
+
+    it('abort while dialing throws AbortError', async () => {
+      const upgradeSpy = sinon.spy(upgrader, 'upgradeOutbound')
+      // Add a delay to connect() so that we can abort while the dial is in
+      // progress
+      connector.delay(100)
+
+      const controller = new AbortController()
+      const conn = transport.dial(addrs[0], { signal: controller.signal })
+      setTimeout(() => controller.abort(), 50)
+
+      await expect(conn).to.eventually.be.rejected().with.property('code', AbortError.code)
+      expect(upgradeSpy.callCount).to.equal(0)
+    })
+  })
+}

package/src/transport/filter-test.ts

@@ -0,0 +1,26 @@
+import { expect } from 'aegir/utils/chai.js'
+import { mockUpgrader } from './utils/index.js'
+import type { TestSetup } from '../index.js'
+import type { Transport } from '@libp2p/interfaces/transport'
+import type { TransportTestFixtures, SetupArgs } from './index.js'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
+  describe('filter', () => {
+    let addrs: Multiaddr[]
+    let transport: Transport<any, any>
+
+    before(async () => {
+      ({ addrs, transport } = await common.setup({ upgrader: mockUpgrader() }))
+    })
+
+    after(async () => {
+      await common.teardown()
+    })
+
+    it('filters addresses', () => {
+      const filteredAddrs = transport.filter(addrs)
+      expect(filteredAddrs).to.eql(addrs)
+    })
+  })
+}