@libp2p/interface-compliance-tests 3.0.5 → 3.0.7-05abd49f

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/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.stat.timeline.open)).to.equal(true)
+
+      void drainAndClose(conn)
+
+      const stream = await onStreamPromise.promise
+      expect(isValidTick(stream.stat.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.stat.timeline.close == null) {
+        throw new Error('timeline had no close time')
+      }
+
+      // Make sure the stream is removed from tracking
+      expect(isValidTick(endedStream.stat.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.stat.timeline.open)).to.equal(true)
+      expect(listener.streams).to.include(conn)
+      expect(isValidTick(conn.stat.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'])
+    })
+  })
+}

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

@@ -0,0 +1,346 @@
+/* eslint max-nested-callbacks: ["error", 8] */
+import { abortableSource } from 'abortable-iterator'
+import { expect } from 'aegir/chai'
+import delay from 'delay'
+import all from 'it-all'
+import drain from 'it-drain'
+import { duplexPair } from 'it-pair/duplex'
+import { pipe } from 'it-pipe'
+import pDefer from 'p-defer'
+import { Uint8ArrayList } from 'uint8arraylist'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import type { TestSetup } from '../index.js'
+import type { StreamMuxerFactory } from '@libp2p/interface/stream-muxer'
+
+function randomBuffer (): Uint8Array {
+  return uint8ArrayFromString(Math.random().toString())
+}
+
+const infiniteRandom = {
+  [Symbol.asyncIterator]: async function * () {
+    while (true) {
+      yield new Uint8ArrayList(randomBuffer())
+      await delay(50)
+    }
+  }
+}
+
+export default (common: TestSetup<StreamMuxerFactory>): void => {
+  describe('close', () => {
+    it('closing underlying socket closes streams', async () => {
+      let openedStreams = 0
+      const expectedStreams = 5
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer({ direction: 'outbound' })
+
+      // Listener is echo server :)
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer({
+        direction: 'inbound',
+        onIncomingStream: (stream) => {
+          openedStreams++
+          void pipe(stream, stream)
+        }
+      })
+
+      const p = duplexPair<Uint8Array>()
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
+
+      const streams = await Promise.all(Array(expectedStreams).fill(0).map(async () => dialer.newStream()))
+
+      void Promise.all(
+        streams.map(async stream => {
+          await pipe(
+            infiniteRandom,
+            stream,
+            drain
+          )
+        })
+      )
+
+      expect(dialer.streams).to.have.lengthOf(expectedStreams)
+
+      // Pause, and then send some data and close the dialer
+      await delay(50)
+      await pipe([randomBuffer()], dialer, drain)
+
+      expect(openedStreams).to.have.equal(expectedStreams)
+      expect(dialer.streams).to.have.lengthOf(0)
+    })
+
+    it('calling close closes streams', async () => {
+      let openedStreams = 0
+      const expectedStreams = 5
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer({ direction: 'outbound' })
+
+      // Listener is echo server :)
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer({
+        direction: 'inbound',
+        onIncomingStream: (stream) => {
+          openedStreams++
+          void pipe(stream, stream).catch(() => {})
+        }
+      })
+
+      const p = duplexPair<Uint8Array>()
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
+
+      const streams = await Promise.all(Array(expectedStreams).fill(0).map(async () => dialer.newStream()))
+
+      void Promise.all(
+        streams.map(async stream => {
+          await pipe(
+            infiniteRandom,
+            stream,
+            drain
+          )
+        })
+      )
+
+      expect(dialer.streams, 'dialer - number of opened streams should match number of calls to newStream').to.have.lengthOf(expectedStreams)
+
+      // Pause, and then close the dialer
+      await delay(50)
+
+      dialer.close()
+
+      expect(openedStreams, 'listener - number of opened streams should match number of calls to newStream').to.have.equal(expectedStreams)
+      expect(dialer.streams, 'all tracked streams should be deleted after the muxer has called close').to.have.lengthOf(0)
+    })
+
+    it('calling close with an error aborts streams', async () => {
+      let openedStreams = 0
+      const expectedStreams = 5
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer({ direction: 'outbound' })
+
+      // Listener is echo server :)
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer({
+        direction: 'inbound',
+        onIncomingStream: (stream) => {
+          openedStreams++
+          void pipe(stream, stream).catch(() => {})
+        }
+      })
+
+      const p = duplexPair<Uint8Array>()
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
+
+      const streams = await Promise.all(Array(expectedStreams).fill(0).map(async () => dialer.newStream()))
+
+      const streamPipes = streams.map(async stream => {
+        await pipe(
+          infiniteRandom,
+          stream,
+          drain
+        )
+      })
+
+      expect(dialer.streams, 'dialer - number of opened streams should match number of calls to newStream').to.have.lengthOf(expectedStreams)
+
+      // Pause, and then close the dialer
+      await delay(50)
+
+      // close _with an error_
+      dialer.close(new Error())
+
+      const timeoutError = new Error('timeout')
+      for (const pipe of streamPipes) {
+        try {
+          await Promise.race([
+            pipe,
+            new Promise((_resolve, reject) => setTimeout(() => { reject(timeoutError) }, 20))
+          ])
+          expect.fail('stream pipe with infinite source should never return')
+        } catch (e) {
+          if (e === timeoutError) {
+            expect.fail('expected stream pipe to throw an error after muxer closed with error')
+          }
+        }
+      }
+
+      expect(openedStreams, 'listener - number of opened streams should match number of calls to newStream').to.have.equal(expectedStreams)
+      expect(dialer.streams, 'all tracked streams should be deleted after the muxer has called close').to.have.lengthOf(0)
+    })
+
+    it('calling newStream after close throws an error', async () => {
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer({ direction: 'outbound' })
+
+      dialer.close()
+
+      try {
+        await dialer.newStream()
+        expect.fail('newStream should throw if called after close')
+      } catch (e) {
+        expect(dialer.streams, 'closed muxer should have no streams').to.have.lengthOf(0)
+      }
+    })
+
+    it('closing one of the muxed streams doesn\'t close others', async () => {
+      const p = duplexPair<Uint8Array>()
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer({ direction: 'outbound' })
+
+      // Listener is echo server :)
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer({
+        direction: 'inbound',
+        onIncomingStream: (stream) => {
+          void pipe(stream, stream).catch(() => {})
+        }
+      })
+
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
+
+      const stream = await dialer.newStream()
+      const streams = await Promise.all(Array.from(Array(5), async () => dialer.newStream()))
+      let closed = false
+      const controllers: AbortController[] = []
+
+      const streamResults = streams.map(async stream => {
+        const controller = new AbortController()
+        controllers.push(controller)
+
+        try {
+          const abortableRand = abortableSource(infiniteRandom, controller.signal, { abortCode: 'ERR_TEST_ABORT' })
+          await pipe(abortableRand, stream, drain)
+        } 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 delay(50)
+      await pipe([new Uint8ArrayList(randomBuffer())], stream, drain)
+      closed = true
+
+      // Abort all the other streams later
+      await delay(50)
+      controllers.forEach(c => { c.abort() })
+
+      // These should now all resolve without error
+      await Promise.all(streamResults)
+    })
+
+    it('can close a stream for writing', async () => {
+      const deferred = pDefer<Error>()
+
+      const p = duplexPair<Uint8Array>()
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer({ direction: 'outbound' })
+      const data = [randomBuffer(), randomBuffer()]
+
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer({
+        direction: 'inbound',
+        onIncomingStream: (stream) => {
+          void Promise.resolve().then(async () => {
+            // Immediate close for write
+            stream.closeWrite()
+
+            const results = await pipe(stream, async (source) => {
+              const data = []
+              for await (const chunk of source) {
+                data.push(chunk.slice())
+              }
+              return data
+            })
+            expect(results).to.eql(data)
+
+            try {
+              await stream.sink([new Uint8ArrayList(randomBuffer())])
+            } catch (err: any) {
+              deferred.resolve(err)
+            }
+
+            deferred.reject(new Error('should not support writing to closed writer'))
+          })
+        }
+      })
+
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
+
+      const stream = await dialer.newStream()
+      await stream.sink(data)
+
+      const err = await deferred.promise
+      expect(err).to.have.property('message').that.matches(/stream closed for writing/)
+    })
+
+    it('can close a stream for reading', async () => {
+      const deferred = pDefer<any>()
+
+      const p = duplexPair<Uint8Array>()
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer({ direction: 'outbound' })
+      const data = [randomBuffer(), randomBuffer()].map(d => new Uint8ArrayList(d))
+
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer({
+        direction: 'inbound',
+        onIncomingStream: (stream) => {
+          void all(stream.source).then(deferred.resolve, deferred.reject)
+        }
+      })
+
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
+
+      const stream = await dialer.newStream()
+      stream.closeRead()
+
+      // Source should be done
+      void Promise.resolve().then(async () => {
+        expect(await stream.source.next()).to.have.property('done', true)
+        await stream.sink(data)
+      })
+
+      const results = await deferred.promise
+      expect(results).to.eql(data)
+    })
+
+    it('calls onStreamEnd for closed streams not previously written', async () => {
+      const deferred = pDefer()
+
+      const onStreamEnd = (): void => { deferred.resolve() }
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer({
+        direction: 'outbound',
+        onStreamEnd
+      })
+
+      const stream = await dialer.newStream()
+
+      stream.close()
+      await deferred.promise
+    })
+
+    it('calls onStreamEnd for read and write closed streams not previously written', async () => {
+      const deferred = pDefer()
+
+      const onStreamEnd = (): void => { deferred.resolve() }
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer({
+        direction: 'outbound',
+        onStreamEnd
+      })
+
+      const stream = await dialer.newStream()
+
+      stream.closeWrite()
+      stream.closeRead()
+      await deferred.promise
+    })
+  })
+}

package/src/stream-muxer/index.ts

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

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

@@ -0,0 +1,14 @@
+import spawn from './spawner.js'
+import type { TestSetup } from '../index.js'
+import type { StreamMuxer, StreamMuxerFactory, StreamMuxerInit } from '@libp2p/interface/stream-muxer'
+
+export default (common: TestSetup<StreamMuxerFactory>): void => {
+  const createMuxer = async (init?: StreamMuxerInit): Promise<StreamMuxer> => {
+    const factory = await common.setup()
+    return factory.createStreamMuxer(init)
+  }
+
+  describe.skip('mega stress test', function () {
+    it('10,000 streams with 10,000 msg', async () => { await spawn(createMuxer, 10000, 10000, 5000) })
+  })
+}