@libp2p/interface-compliance-tests 2.0.3 → 3.0.0

package/src/record/index.ts

@@ -1,32 +0,0 @@
-import { expect } from 'aegir/chai'
-import type { TestSetup } from '../index.js'
-import type { Record } from '@libp2p/interfaces/record'
-
-export default (test: TestSetup<Record>) => {
-  describe('record', () => {
-    let record: Record
-
-    beforeEach(async () => {
-      record = await test.setup()
-    })
-
-    afterEach(async () => {
-      await test.teardown()
-    })
-
-    it('has domain and codec', () => {
-      expect(record.domain).to.exist()
-      expect(record.codec).to.exist()
-    })
-
-    it('is able to marshal', () => {
-      const rawData = record.marshal()
-      expect(rawData).to.be.an.instanceof(Uint8Array)
-    })
-
-    it('is able to compare two records', () => {
-      const equals = record.equals(record)
-      expect(equals).to.eql(true)
-    })
-  })
-}

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

@@ -1,190 +0,0 @@
-import { expect } from 'aegir/chai'
-import { duplexPair } from 'it-pair/duplex'
-import { pipe } from 'it-pipe'
-import drain from 'it-drain'
-import map from 'it-map'
-import all from 'it-all'
-import defer from 'p-defer'
-import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { isValidTick } from '../utils/is-valid-tick.js'
-import type { DeferredPromise } from 'p-defer'
-import type { TestSetup } from '../index.js'
-import type { Stream } from '@libp2p/interfaces/connection'
-import type { StreamMuxerFactory } from '@libp2p/interfaces/stream-muxer'
-import type { Source, Duplex } from 'it-stream-types'
-import { Components } from '@libp2p/interfaces/components'
-
-async function drainAndClose (stream: Duplex<Uint8Array>) {
-  return await pipe([], stream, drain)
-}
-
-export default (common: TestSetup<StreamMuxerFactory>) => {
-  describe('base', () => {
-    it('Open a stream from the dialer', async () => {
-      const p = duplexPair<Uint8Array>()
-      const dialerFactory = await common.setup()
-      const dialer = dialerFactory.createStreamMuxer(new Components())
-      const onStreamPromise: DeferredPromise<Stream> = defer()
-      const onStreamEndPromise: DeferredPromise<Stream> = defer()
-
-      const listenerFactory = await common.setup()
-      const listener = listenerFactory.createStreamMuxer(new Components(), {
-        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 = 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(new Components(), {
-        onIncomingStream: (stream: Stream) => {
-          onStreamPromise.resolve(stream)
-        }
-      })
-
-      const listenerFactory = await common.setup()
-      const listener = listenerFactory.createStreamMuxer(new Components())
-
-      void pipe(p[0], dialer, p[0])
-      void pipe(p[1], listener, p[1])
-
-      const conn = 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(new Components(), {
-        onIncomingStream: (stream) => {
-          onDialerStreamPromise.resolve(stream)
-        }
-      })
-
-      const listenerFactory = await common.setup()
-      const listener = listenerFactory.createStreamMuxer(new Components(), {
-        onIncomingStream: (stream) => {
-          onListenerStreamPromise.resolve(stream)
-        }
-      })
-
-      void pipe(p[0], dialer, p[0])
-      void pipe(p[1], listener, p[1])
-
-      const dialerInitiatorStream = dialer.newStream()
-      const listenerInitiatorStream = 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<Uint8Array>) => map(source, (u) => uint8ArrayToString(u))
-      const p = duplexPair<Uint8Array>()
-      const onDialerStreamPromise: DeferredPromise<Stream> = defer()
-      const onListenerStreamPromise: DeferredPromise<Stream> = defer()
-      const dialerFactory = await common.setup()
-      const dialer = dialerFactory.createStreamMuxer(new Components(), {
-        onIncomingStream: (stream) => {
-          onDialerStreamPromise.resolve(stream)
-        }
-      })
-      const listenerFactory = await common.setup()
-      const listener = listenerFactory.createStreamMuxer(new Components(), {
-        onIncomingStream: (stream) => {
-          onListenerStreamPromise.resolve(stream)
-        }
-      })
-
-      void pipe(p[0], dialer, p[0])
-      void pipe(p[1], listener, p[1])
-
-      const dialerConn = dialer.newStream()
-      const listenerConn = listener.newStream()
-
-      void pipe([uint8ArrayFromString('hey')], dialerConn)
-      void pipe([uint8ArrayFromString('hello')], listenerConn)
-
-      const [
-        dialerStream,
-        listenerStream
-      ] = await Promise.all([
-        onDialerStreamPromise.promise,
-        onListenerStreamPromise.promise
-      ])
-
-      const [
-        listenerChunks,
-        dialerChunks
-      ] = await Promise.all([
-        pipe(listenerStream, toString, async (source) => await all(source)),
-        pipe(dialerStream, toString, async (source) => await all(source))
-      ])
-
-      expect(listenerChunks).to.be.eql(['hey'])
-      expect(dialerChunks).to.be.eql(['hello'])
-    })
-  })
-}

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

@@ -1,227 +0,0 @@
-/* eslint max-nested-callbacks: ["error", 8] */
-import { pipe } from 'it-pipe'
-import { duplexPair } from 'it-pair/duplex'
-import { abortableSource } from 'abortable-iterator'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import drain from 'it-drain'
-import { expect } from 'aegir/chai'
-import delay from 'delay'
-import type { TestSetup } from '../index.js'
-import type { StreamMuxerFactory } from '@libp2p/interfaces/stream-muxer'
-import { Components } from '@libp2p/interfaces/components'
-import pDefer from 'p-defer'
-import all from 'it-all'
-
-function randomBuffer () {
-  return uint8ArrayFromString(Math.random().toString())
-}
-
-const infiniteRandom = {
-  [Symbol.asyncIterator]: async function * () {
-    while (true) {
-      yield randomBuffer()
-      await delay(50)
-    }
-  }
-}
-
-export default (common: TestSetup<StreamMuxerFactory>) => {
-  describe('close', () => {
-    it('closing underlying socket closes streams', async () => {
-      let openedStreams = 0
-      const expectedStreams = 5
-      const dialerFactory = await common.setup()
-      const dialer = dialerFactory.createStreamMuxer(new Components())
-
-      // Listener is echo server :)
-      const listenerFactory = await common.setup()
-      const listener = listenerFactory.createStreamMuxer(new Components(), {
-        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 = Array(expectedStreams).fill(0).map(() => dialer.newStream())
-
-      void Promise.all(
-        streams.map(async stream => {
-          return 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('closing one of the muxed streams doesn\'t close others', async () => {
-      const p = duplexPair<Uint8Array>()
-      const dialerFactory = await common.setup()
-      const dialer = dialerFactory.createStreamMuxer(new Components())
-
-      // Listener is echo server :)
-      const listenerFactory = await common.setup()
-      const listener = listenerFactory.createStreamMuxer(new Components(), {
-        onIncomingStream: (stream) => {
-          void pipe(stream, stream)
-        }
-      })
-
-      void pipe(p[0], dialer, p[0])
-      void 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 = 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([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<any>()
-
-      const p = duplexPair<Uint8Array>()
-      const dialerFactory = await common.setup()
-      const dialer = dialerFactory.createStreamMuxer(new Components())
-      const data = [randomBuffer(), randomBuffer()]
-
-      const listenerFactory = await common.setup()
-      const listener = listenerFactory.createStreamMuxer(new Components(), {
-        onIncomingStream: (stream) => {
-          void Promise.resolve().then(async () => {
-            // Immediate close for write
-            await 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([randomBuffer()])
-            } catch (err) {
-              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 = 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(new Components())
-      const data = [randomBuffer(), randomBuffer()]
-
-      const listenerFactory = await common.setup()
-      const listener = listenerFactory.createStreamMuxer(new Components(), {
-        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 = dialer.newStream()
-      await stream.closeRead()
-
-      // Source should be done
-      void Promise.resolve().then(async () => {
-        // @ts-expect-error next is part of the iterable protocol
-        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 = () => deferred.resolve()
-      const dialerFactory = await common.setup()
-      const dialer = dialerFactory.createStreamMuxer(new Components(), {
-        onStreamEnd
-      })
-
-      const stream = await dialer.newStream()
-
-      await stream.close()
-      await deferred.promise
-    })
-
-    it('calls onStreamEnd for read and write closed streams not previously written', async () => {
-      const deferred = pDefer()
-
-      const onStreamEnd = () => deferred.resolve()
-      const dialerFactory = await common.setup()
-      const dialer = dialerFactory.createStreamMuxer(new Components(), {
-        onStreamEnd
-      })
-
-      const stream = await dialer.newStream()
-
-      await stream.closeWrite()
-      await stream.closeRead()
-      await deferred.promise
-    })
-  })
-}

package/src/stream-muxer/index.ts

@@ -1,15 +0,0 @@
-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 { StreamMuxerFactory } from '@libp2p/interfaces/stream-muxer'
-
-export default (common: TestSetup<StreamMuxerFactory>) => {
-  describe('interface-stream-muxer', () => {
-    baseTest(common)
-    closeTest(common)
-    stressTest(common)
-    megaStressTest(common)
-  })
-}

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

@@ -1,15 +0,0 @@
-import spawn from './spawner.js'
-import type { TestSetup } from '../index.js'
-import type { StreamMuxer, StreamMuxerFactory, StreamMuxerInit } from '@libp2p/interfaces/stream-muxer'
-import { Components } from '@libp2p/interfaces/components'
-
-export default (common: TestSetup<StreamMuxerFactory>) => {
-  const createMuxer = async (init?: StreamMuxerInit): Promise<StreamMuxer> => {
-    const factory = await common.setup()
-    return factory.createStreamMuxer(new Components(), init)
-  }
-
-  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

@@ -1,52 +0,0 @@
-import { expect } from 'aegir/chai'
-import { duplexPair } from 'it-pair/duplex'
-import { pipe } from 'it-pipe'
-import pLimit from 'p-limit'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import drain from 'it-drain'
-import all from 'it-all'
-import type { StreamMuxer, StreamMuxerInit } from '@libp2p/interfaces/stream-muxer'
-
-export default async (createMuxer: (init?: StreamMuxerInit) => Promise<StreamMuxer>, nStreams: number, nMsg: number, limit?: number) => {
-  const [dialerSocket, listenerSocket] = duplexPair<Uint8Array>()
-
-  const msg = uint8ArrayFromString('simple msg')
-
-  const listener = await createMuxer({
-    onIncomingStream: (stream) => {
-      void pipe(
-        stream,
-        drain
-      ).then(() => {
-        stream.close()
-      })
-    }
-  })
-  const dialer = await createMuxer()
-
-  void pipe(listenerSocket, listener, listenerSocket)
-  void pipe(dialerSocket, dialer, dialerSocket)
-
-  const spawnStream = async () => {
-    const stream = dialer.newStream()
-    expect(stream).to.exist // eslint-disable-line
-
-    const res = await pipe(
-      (async function * () {
-        for (let i = 0; i < nMsg; i++) {
-          yield msg
-        }
-      }()),
-      stream,
-      async (source) => await all(source)
-    )
-
-    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

@@ -1,29 +0,0 @@
-import spawn from './spawner.js'
-import type { TestSetup } from '../index.js'
-import type { StreamMuxerFactory, StreamMuxerInit, StreamMuxer } from '@libp2p/interfaces/stream-muxer'
-import { Components } from '@libp2p/interfaces/components'
-
-export default (common: TestSetup<StreamMuxerFactory>) => {
-  const createMuxer = async (init?: StreamMuxerInit): Promise<StreamMuxer> => {
-    const factory = await common.setup()
-    return factory.createStreamMuxer(new Components(), init)
-  }
-
-  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 () {
-      this.timeout(120000)
-      await spawn(createMuxer, 1000, 100)
-    })
-  })
-}

package/src/topology/topology.ts

@@ -1,25 +0,0 @@
-import { expect } from 'aegir/chai'
-import sinon from 'sinon'
-import type { TestSetup } from '../index.js'
-import type { Topology } from '@libp2p/interfaces/topology'
-
-export default (test: TestSetup<Topology>) => {
-  describe('topology', () => {
-    let topology: Topology
-
-    beforeEach(async () => {
-      topology = await test.setup()
-    })
-
-    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()
-    })
-  })
-}