@libp2p/interface-compliance-tests 6.5.0-8484de8a2 → 6.5.0-87bc8d4fb

package/src/stream-muxer/index.ts

@@ -1,6 +1,6 @@
 import baseTest from './base-test.js'
 import closeTest from './close-test.js'
-import steamTest from './stream-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'
@@ -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/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'
+
+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) })
+  })
+}

package/src/stream-muxer/spawner.ts

@@ -0,0 +1,57 @@
+import { expect } from 'aegir/chai'
+import all from 'it-all'
+import drain from 'it-drain'
+import { duplexPair } from 'it-pair/duplex'
+import { pipe } from 'it-pipe'
+import pLimit from 'p-limit'
+import { Uint8ArrayList } from 'uint8arraylist'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import type { StreamMuxer, StreamMuxerInit } from '@libp2p/interface'
+
+export default async (createMuxer: (init?: StreamMuxerInit) => Promise<StreamMuxer>, nStreams: number, nMsg: number, limit?: number): Promise<void> => {
+  const [dialerSocket, listenerSocket] = duplexPair<Uint8Array | Uint8ArrayList>()
+
+  const msg = new Uint8ArrayList(uint8ArrayFromString('simple msg'))
+
+  const listener = await createMuxer({
+    direction: 'inbound',
+    onIncomingStream: (stream) => {
+      void pipe(
+        stream,
+        drain
+      ).then(async () => {
+        await stream.close()
+      })
+        .catch(err => { stream.abort(err) })
+    }
+  })
+  const dialer = await createMuxer({
+    direction: 'outbound'
+  })
+
+  void pipe(listenerSocket, listener, listenerSocket)
+  void pipe(dialerSocket, dialer, dialerSocket)
+
+  const spawnStream = async (): Promise<void> => {
+    const stream = await 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) => 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,101 +1,27 @@
-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 spawn from './spawner.js'
 import type { TestSetup } from '../index.js'
-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()
-}
+import type { StreamMuxerFactory, StreamMuxerInit, StreamMuxer } from '@libp2p/interface'
 
 export default (common: TestSetup<StreamMuxerFactory>): void => {
-  const createMuxer = async (maConn: MultiaddrConnection): Promise<StreamMuxer> => {
+  const createMuxer = async (init?: StreamMuxerInit): Promise<StreamMuxer> => {
     const factory = await common.setup()
-    return factory.createStreamMuxer(maConn)
+    return factory.createStreamMuxer(init)
   }
 
-  const streams = [1, 10, 100, 1000]
-  const messages = [1, 10, 100]
-
   describe('stress test', function () {
-    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])
-        })
-      }
-    }
+    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) })
   })
 }