@libp2p/interface-compliance-tests 6.4.16 → 6.5.0-8484de8a2

package/src/stream-muxer/index.ts

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

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

@@ -0,0 +1,380 @@
+import { StreamCloseEvent, StreamMessageEvent } from '@libp2p/interface'
+import { multiaddrConnectionPair } from '@libp2p/utils'
+import { expect } from 'aegir/chai'
+import delay from 'delay'
+import all from 'it-all'
+import { pEvent } from 'p-event'
+import Sinon from 'sinon'
+import { Uint8ArrayList } from 'uint8arraylist'
+import { isValidTick } from '../is-valid-tick.ts'
+import type { TestSetup } from '../index.ts'
+import type { MultiaddrConnection, Stream, StreamMuxer, StreamMuxerFactory } from '@libp2p/interface'
+
+export default (common: TestSetup<StreamMuxerFactory>): void => {
+  describe('streams', () => {
+    let dialer: StreamMuxer
+    let listener: StreamMuxer
+    let outboundStream: Stream
+    let inboundStream: Stream
+    let streams: [Stream, Stream]
+    let outboundConnection: MultiaddrConnection
+    let inboundConnection: MultiaddrConnection
+
+    beforeEach(async () => {
+      ([outboundConnection, inboundConnection] = multiaddrConnectionPair())
+
+      const dialerFactory = await common.setup()
+      dialer = dialerFactory.createStreamMuxer(outboundConnection)
+
+      const listenerFactory = await common.setup()
+      listener = listenerFactory.createStreamMuxer(inboundConnection)
+
+      streams = await Promise.all([
+        pEvent<'stream', CustomEvent<Stream>>(listener, 'stream').then(evt => evt.detail),
+        dialer.createStream()
+      ])
+
+      inboundStream = streams[0]
+      outboundStream = streams[1]
+    })
+
+    afterEach(async () => {
+      await dialer?.close()
+      await listener?.close()
+    })
+
+    it('should have correct status after opening', () => {
+      streams.forEach(stream => {
+        expect(stream).to.have.property('status', 'open', `${stream.direction} stream status was incorrect`)
+        expect(stream).to.have.property('writeStatus', 'writable', `${stream.direction} stream writeStatus was incorrect`)
+        expect(stream).to.have.property('readStatus', 'readable', `${stream.direction} stream readStatus was incorrect`)
+      })
+    })
+
+    it('should have correct timeline after opening', () => {
+      streams.forEach(stream => {
+        expect(isValidTick(stream.timeline.open)).to.equal(true, `${stream.direction} stream timeline.open was incorrect`)
+        expect(stream).to.not.have.nested.property('timeline.close', `${stream.direction} stream timeline.close was incorrect`)
+        expect(stream).to.not.have.nested.property('timeline.closeRead', `${stream.direction} stream timeline.closeRead was incorrect`)
+        expect(stream).to.not.have.nested.property('timeline.closeWrite', `${stream.direction} stream timeline.closeWrite was incorrect`)
+        expect(stream).to.not.have.nested.property('timeline.reset', `${stream.direction} stream timeline.reset was incorrect`)
+        expect(stream).to.not.have.nested.property('timeline.abort', `${stream.direction} stream timeline.abort was incorrect`)
+      })
+    })
+
+    it('outbound stream sends data', async () => {
+      const messageEventPromise = pEvent<'message', StreamMessageEvent>(inboundStream, 'message')
+      const data = Uint8Array.from([0, 1, 2, 3, 4])
+
+      outboundStream.send(data)
+
+      const evt = await messageEventPromise
+      expect(evt.data.subarray()).to.equalBytes(data)
+    })
+
+    it('inbound stream sends data', async () => {
+      const messageEventPromise = pEvent<'message', StreamMessageEvent>(outboundStream, 'message')
+      const data = Uint8Array.from([0, 1, 2, 3, 4])
+
+      inboundStream.send(data)
+
+      const evt = await messageEventPromise
+      expect(evt.data.subarray()).to.equalBytes(data)
+    })
+
+    it('closes', async () => {
+      const signal = AbortSignal.timeout(1_000)
+
+      void outboundStream.close({
+        signal
+      })
+      void inboundStream.close({
+        signal
+      })
+
+      expect(outboundStream).to.have.property('status', 'open')
+      expect(outboundStream).to.have.property('readStatus', 'readable')
+      expect(outboundStream).to.have.property('writeStatus', 'closing')
+
+      await Promise.all([
+        pEvent(outboundStream, 'close', {
+          signal
+        }),
+        pEvent(inboundStream, 'close', {
+          signal
+        })
+      ])
+
+      streams.forEach(stream => {
+        expect(stream).to.have.property('status', 'closed', `${stream.direction} stream status was incorrect`)
+        expect(stream).to.have.property('writeStatus', 'closed', `${stream.direction} stream writeStatus was incorrect`)
+        expect(stream).to.have.property('readStatus', 'closed', `${stream.direction} stream readStatus was incorrect`)
+
+        expect(isValidTick(stream.timeline.open)).to.equal(true, `${stream.direction} stream timeline.open was incorrect`)
+        expect(isValidTick(stream.timeline.close)).to.equal(true, `${stream.direction} stream timeline.close was incorrect`)
+
+        expect(stream).to.not.have.nested.property('timeline.reset', `${stream.direction} stream timeline.reset was incorrect`)
+        expect(stream).to.not.have.nested.property('timeline.abort', `${stream.direction} stream timeline.abort was incorrect`)
+      })
+    })
+
+    it('should send large amounts of data in both directions', async function () {
+      const timeout = 360_000
+      this.timeout(timeout)
+
+      const sent = new Array(10)
+        .fill(0)
+        .map((val, index) => new Uint8Array(1024 * 1024).fill(index))
+
+      // send data in both directions simultaneously
+      const [
+        outboundReceived,
+        inboundReceived
+      ] = await Promise.all([
+        all(outboundStream),
+        all(inboundStream),
+        (async () => {
+          for (const buf of sent) {
+            if (!outboundStream.send(buf)) {
+              await pEvent(outboundStream, 'drain', {
+                rejectionEvents: [
+                  'close'
+                ]
+              })
+            }
+          }
+
+          await outboundStream.close()
+        })(),
+        (async () => {
+          for (const buf of sent) {
+            if (!inboundStream.send(buf)) {
+              await pEvent(inboundStream, 'drain', {
+                rejectionEvents: [
+                  'close'
+                ]
+              })
+            }
+          }
+
+          await inboundStream.close()
+        })()
+      ])
+
+      expect(new Uint8ArrayList(...outboundReceived)).to.have.property('byteLength', new Uint8ArrayList(...sent).byteLength)
+      expect(new Uint8ArrayList(...inboundReceived)).to.have.property('byteLength', new Uint8ArrayList(...sent).byteLength)
+    })
+
+    it('closes for writing', async () => {
+      const signal = AbortSignal.timeout(1_000)
+
+      const eventPromise = pEvent(inboundStream, 'remoteCloseWrite')
+
+      void outboundStream.close({
+        signal
+      })
+
+      expect(outboundStream).to.have.property('writeStatus', 'closing')
+
+      await delay(100)
+
+      expect(inboundStream).to.have.property('readStatus', 'readable')
+
+      await eventPromise
+
+      streams.forEach(stream => {
+        expect(stream).to.have.property('status', 'open', `${stream.direction} stream status was incorrect`)
+
+        expect(isValidTick(stream.timeline.open)).to.equal(true, `${stream.direction} stream timeline.open was incorrect`)
+
+        expect(stream).to.not.have.nested.property('timeline.close', `${stream.direction} stream timeline.close was incorrect`)
+        expect(stream).to.not.have.nested.property('timeline.reset', `${stream.direction} stream timeline.reset was incorrect`)
+        expect(stream).to.not.have.nested.property('timeline.abort', `${stream.direction} stream timeline.abort was incorrect`)
+      })
+
+      expect(outboundStream).to.have.property('writeStatus', 'closed', 'outbound stream writeStatus was incorrect')
+      expect(outboundStream).to.have.property('readStatus', 'readable', 'inbound stream readStatus was incorrect')
+
+      expect(outboundStream).to.not.have.nested.property('timeline.closeRead', 'inbound stream timeline.closeRead was incorrect')
+
+      expect(inboundStream).to.have.property('writeStatus', 'writable', 'inbound stream writeStatus was incorrect')
+      expect(inboundStream).to.have.property('readStatus', 'readable', 'inbound stream readStatus was incorrect')
+    })
+
+    it('aborts', async () => {
+      const eventPromises = Promise.all([
+        pEvent<'close', StreamCloseEvent>(outboundStream, 'close'),
+        pEvent<'close', StreamCloseEvent>(inboundStream, 'close')
+      ])
+
+      const err = new Error('Urk!')
+      outboundStream.abort(err)
+
+      const [outboundEvent, inboundEvent] = await eventPromises
+
+      streams.forEach(stream => {
+        expect(stream).to.have.property('writeStatus', 'closed', `${stream.direction} stream writeStatus was incorrect`)
+        expect(stream).to.have.property('readStatus', 'closed', `${stream.direction} stream readStatus was incorrect`)
+
+        expect(isValidTick(stream.timeline.open)).to.equal(true, `${stream.direction} stream timeline.open was incorrect`)
+
+        expect(stream).to.not.have.nested.property('timeline.close', `${stream.direction} stream timeline.close was incorrect`)
+      })
+
+      expect(outboundStream).to.have.property('status', 'aborted', 'outbound stream status was incorrect')
+      expect(isValidTick(outboundStream.timeline.close)).to.equal(true, 'outbound stream timeline.abort was incorrect')
+
+      expect(inboundStream).to.have.property('status', 'reset', 'inbound stream status was incorrect')
+      expect(isValidTick(inboundStream.timeline.close)).to.equal(true, 'inbound stream timeline.reset was incorrect')
+
+      expect(() => outboundStream.send(Uint8Array.from([0, 1, 2, 3]))).to.throw()
+        .with.property('name', 'StreamStateError', 'could still write to aborted stream')
+
+      expect(() => inboundStream.send(Uint8Array.from([0, 1, 2, 3]))).to.throw()
+        .with.property('name', 'StreamStateError', 'could still write to reset stream')
+
+      expect(outboundEvent).to.have.property('error', err)
+      expect(inboundEvent).to.have.nested.property('error.name', 'StreamResetError')
+    })
+
+    it('does not send close read when remote closes write', async () => {
+      // @ts-expect-error internal method of AbstractMessageStream
+      const sendCloseReadSpy = Sinon.spy(outboundStream, 'sendCloseRead')
+
+      await Promise.all([
+        pEvent(outboundStream, 'remoteCloseWrite'),
+        inboundStream.close()
+      ])
+
+      await delay(100)
+
+      expect(sendCloseReadSpy.called).to.be.false()
+    })
+
+    it('does not send close read or write when remote resets', async () => {
+      // @ts-expect-error internal method of AbstractMessageStream
+      const sendCloseReadSpy = Sinon.spy(outboundStream, 'sendCloseRead')
+      // @ts-expect-error internal method of AbstractMessageStream
+      const sendCloseWriteSpy = Sinon.spy(outboundStream, 'sendCloseWrite')
+
+      await Promise.all([
+        pEvent(outboundStream, 'close'),
+        inboundStream.abort(new Error('Urk!'))
+      ])
+
+      await delay(100)
+
+      await outboundStream.close()
+
+      await delay(100)
+
+      expect(sendCloseReadSpy.called).to.be.false()
+      expect(sendCloseWriteSpy.called).to.be.false()
+    })
+
+    it('should wait for sending data to finish when closing gracefully', async () => {
+      let sent = 0
+      let received = 0
+      let filledBuffer = false
+      const receivedAll = Promise.withResolvers<boolean>()
+
+      inboundStream.addEventListener('message', (evt) => {
+        received += evt.data.byteLength
+
+        if (filledBuffer && received === sent) {
+          receivedAll.resolve(true)
+        }
+      })
+
+      // fill the send buffer
+      while (true) {
+        const length = 1024
+        sent += length
+        const sendMore = outboundStream.send(new Uint8Array(length))
+
+        if (sendMore === false) {
+          filledBuffer = true
+          break
+        }
+      }
+
+      expect(outboundStream.writeStatus).to.equal('writable')
+      expect(outboundStream.writableNeedsDrain).to.be.true()
+
+      // close gracefully
+      await outboundStream.close()
+
+      await expect(receivedAll.promise).to.eventually.be.true('did not receive all data')
+    })
+
+    it('should wait for sending data to finish when closing the writable end gracefully', async () => {
+      let sent = 0
+      let received = 0
+      let filledBuffer = false
+      const receivedAll = Promise.withResolvers<boolean>()
+
+      inboundStream.addEventListener('message', (evt) => {
+        received += evt.data.byteLength
+
+        if (filledBuffer && received === sent) {
+          receivedAll.resolve(true)
+        }
+      })
+
+      // fill the send buffer
+      while (true) {
+        const length = 1024
+        sent += length
+        const sendMore = outboundStream.send(new Uint8Array(length))
+
+        if (sendMore === false) {
+          filledBuffer = true
+          break
+        }
+      }
+
+      expect(outboundStream.writeStatus).to.equal('writable')
+      expect(outboundStream.writableNeedsDrain).to.be.true()
+
+      // close gracefully
+      await outboundStream.close()
+
+      await expect(receivedAll.promise).to.eventually.be.true('did not receive all data')
+    })
+
+    it('should abort close due to timeout with slow sender', async () => {
+      const chunkSize = 1024
+
+      // make the 'drain' event slow to fire
+      // @ts-expect-error private fields
+      outboundConnection.local.delay = 1000
+
+      inboundStream = streams[0]
+      outboundStream = streams[1]
+
+      // ensure there are bytes left in the write queue
+      // @ts-expect-error private fields
+      outboundStream.maxMessageSize = chunkSize - 1
+
+      // fill the send buffer
+      while (true) {
+        const sendMore = outboundStream.send(new Uint8Array(chunkSize * 10))
+
+        if (sendMore === false) {
+          expect(outboundStream).to.have.nested.property('writeBuffer.byteLength').that.is.greaterThan(0)
+
+          break
+        }
+      }
+
+      expect(outboundStream.writeStatus).to.equal('writable')
+      expect(outboundStream.writableNeedsDrain).to.be.true()
+
+      // close stream, should be aborted as drain event will not have fired
+      await expect(outboundStream.close({
+        signal: AbortSignal.timeout(10)
+      })).to.eventually.be.rejected
+        .with.property('name', 'TimeoutError')
+    })
+  })
+}

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

@@ -1,27 +1,101 @@
-import spawn from './spawner.js'
+import { multiaddrConnectionPair, echo } from '@libp2p/utils'
+import { expect } from 'aegir/chai'
+import { pEvent } from 'p-event'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import type { TestSetup } from '../index.js'
-import type { StreamMuxerFactory, StreamMuxerInit, StreamMuxer } from '@libp2p/interface'
+import type { StreamMuxerFactory, StreamMuxer, MultiaddrConnection } from '@libp2p/interface'
+
+async function * messages (nMsg: number): AsyncGenerator<Uint8Array> {
+  for (let i = 0; i < nMsg; i++) {
+    yield uint8ArrayFromString(`message ${i + 1}/${nMsg}`)
+  }
+}
+
+async function spawn (createMuxer: (maConn: MultiaddrConnection) => Promise<StreamMuxer>, nStreams: number, nMsg: number): Promise<void> {
+  const [outboundConnection, inboundConnection] = multiaddrConnectionPair()
+
+  const listener = await createMuxer(inboundConnection)
+  listener.addEventListener('stream', function echoStreamHandler (evt) {
+    echo(evt.detail)
+      .catch(err => {
+        evt.detail.abort(err)
+      })
+  })
+
+  const dialer = await createMuxer(outboundConnection)
+
+  const spawnStream = async (): Promise<void> => {
+    let receivedBytes = 0
+    let sentBytes = 0
+
+    for await (const buf of messages(nMsg)) {
+      sentBytes += buf.byteLength
+    }
+
+    const receivedAllMessagesPromise = Promise.withResolvers<void>()
+    const outboundStream = await dialer.createStream()
+
+    outboundStream.addEventListener('message', function countMessages (evt) {
+      receivedBytes += evt.data.byteLength
+
+      outboundStream.log('%s - echoed bytes %d/%d', uint8ArrayToString(evt.data.subarray()), receivedBytes, sentBytes)
+
+      if (receivedBytes === sentBytes) {
+        outboundStream.log('received all bytes')
+        receivedAllMessagesPromise.resolve()
+      }
+    })
+
+    for await (const buf of messages(nMsg)) {
+      const sendMore = outboundStream.send(buf)
+
+      if (sendMore === false) {
+        await pEvent(outboundStream, 'drain', {
+          rejectionEvents: ['close']
+        })
+      }
+    }
+
+    await receivedAllMessagesPromise.promise
+    outboundStream.log('sent and received all messages %d/%d', receivedBytes, sentBytes)
+
+    await Promise.all([
+      pEvent(outboundStream, 'close'),
+      outboundStream.close()
+    ])
+
+    expect(receivedBytes).to.equal(sentBytes)
+  }
+
+  await Promise.all(
+    Array.from(Array(nStreams), async () => {
+      await spawnStream()
+    })
+  )
+
+  await listener.close()
+  await dialer.close()
+}
 
 export default (common: TestSetup<StreamMuxerFactory>): void => {
-  const createMuxer = async (init?: StreamMuxerInit): Promise<StreamMuxer> => {
+  const createMuxer = async (maConn: MultiaddrConnection): Promise<StreamMuxer> => {
     const factory = await common.setup()
-    return factory.createStreamMuxer(init)
+    return factory.createStreamMuxer(maConn)
   }
 
+  const streams = [1, 10, 100, 1000]
+  const messages = [1, 10, 100]
+
   describe('stress test', function () {
-    this.timeout(1600000)
-
-    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 () => { await spawn(createMuxer, 1000, 100) })
+    this.timeout(1_600_000)
+
+    for (let i = 0; i < streams.length; i++) {
+      for (let j = 0; j < messages.length; j++) {
+        it(`${streams[i]} stream(s) with ${messages[j]} msg(s)`, async () => {
+          await spawn(createMuxer, streams[i], messages[j])
+        })
+      }
+    }
   })
 }