@libp2p/interface-compliance-tests 3.0.7 → 4.0.0

package/src/stream-muxer/fixtures/pb/message.ts

@@ -0,0 +1,87 @@
+/* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+
+import { encodeMessage, decodeMessage, message } from 'protons-runtime'
+import type { Codec } from 'protons-runtime'
+import type { Uint8ArrayList } from 'uint8arraylist'
+
+export interface Message {
+  message: string
+  value: number
+  flag: boolean
+}
+
+export namespace Message {
+  let _codec: Codec<Message>
+
+  export const codec = (): Codec<Message> => {
+    if (_codec == null) {
+      _codec = message<Message>((obj, w, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          w.fork()
+        }
+
+        if ((obj.message != null && obj.message !== '')) {
+          w.uint32(10)
+          w.string(obj.message)
+        }
+
+        if ((obj.value != null && obj.value !== 0)) {
+          w.uint32(16)
+          w.uint32(obj.value)
+        }
+
+        if ((obj.flag != null && obj.flag !== false)) {
+          w.uint32(24)
+          w.bool(obj.flag)
+        }
+
+        if (opts.lengthDelimited !== false) {
+          w.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {
+          message: '',
+          value: 0,
+          flag: false
+        }
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.message = reader.string()
+              break
+            case 2:
+              obj.value = reader.uint32()
+              break
+            case 3:
+              obj.flag = reader.bool()
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
+  }
+
+  export const encode = (obj: Partial<Message>): Uint8Array => {
+    return encodeMessage(obj, Message.codec())
+  }
+
+  export const decode = (buf: Uint8Array | Uint8ArrayList): Message => {
+    return decodeMessage(buf, Message.codec())
+  }
+}

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) })
+  })
+}

package/src/stream-muxer/spawner.ts

@@ -0,0 +1,55 @@
+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/stream-muxer'
+
+export default async (createMuxer: (init?: StreamMuxerInit) => Promise<StreamMuxer>, nStreams: number, nMsg: number, limit?: number): Promise<void> => {
+  const [dialerSocket, listenerSocket] = duplexPair<Uint8Array>()
+
+  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

@@ -0,0 +1,27 @@
+import spawn from './spawner.js'
+import type { TestSetup } from '../index.js'
+import type { StreamMuxerFactory, StreamMuxerInit, StreamMuxer } 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('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) })
+  })
+}

package/src/transport/dial-test.ts

@@ -0,0 +1,124 @@
+import { AbortError } from '@libp2p/interface/errors'
+import { EventEmitter } from '@libp2p/interface/events'
+import { expect } from 'aegir/chai'
+import all from 'it-all'
+import drain from 'it-drain'
+import { pipe } from 'it-pipe'
+import sinon from 'sinon'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { isValidTick } from '../is-valid-tick.js'
+import { mockUpgrader, mockRegistrar } from '../mocks/index.js'
+import type { TransportTestFixtures, Connector } from './index.js'
+import type { TestSetup } from '../index.js'
+import type { Listener, Transport, Upgrader } from '@libp2p/interface/transport'
+import type { Registrar } from '@libp2p/interface-internal/registrar'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+export default (common: TestSetup<TransportTestFixtures>): void => {
+  describe('dial', () => {
+    let upgrader: Upgrader
+    let registrar: Registrar
+    let addrs: Multiaddr[]
+    let transport: Transport
+    let connector: Connector
+    let listener: Listener
+
+    before(async () => {
+      registrar = mockRegistrar()
+      upgrader = mockUpgrader({
+        registrar,
+        events: new EventEmitter()
+      });
+
+      ({ addrs, transport, connector } = await common.setup())
+    })
+
+    after(async () => {
+      await common.teardown()
+    })
+
+    beforeEach(async () => {
+      listener = transport.createListener({
+        upgrader
+      })
+      await listener.listen(addrs[0])
+    })
+
+    afterEach(async () => {
+      sinon.restore()
+      connector.restore()
+      await listener.close()
+    })
+
+    it('simple', async () => {
+      const protocol = '/hello/1.0.0'
+      void registrar.handle(protocol, (data) => {
+        void pipe([
+          uint8ArrayFromString('hey')
+        ],
+        data.stream,
+        drain
+        )
+      })
+
+      const upgradeSpy = sinon.spy(upgrader, 'upgradeOutbound')
+      const conn = await transport.dial(addrs[0], {
+        upgrader
+      })
+
+      const stream = await conn.newStream([protocol])
+      const result = await all(stream.source)
+
+      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].subarray()).to.equalBytes(uint8ArrayFromString('hey'))
+      await conn.close()
+    })
+
+    it('can close connections', async () => {
+      const upgradeSpy = sinon.spy(upgrader, 'upgradeOutbound')
+      const conn = await transport.dial(addrs[0], {
+        upgrader
+      })
+
+      expect(upgradeSpy.callCount).to.equal(1)
+      await expect(upgradeSpy.getCall(0).returnValue).to.eventually.equal(conn)
+      await conn.close()
+      expect(isValidTick(conn.timeline.close)).to.equal(true)
+    })
+
+    it('to non existent listener', async () => {
+      const upgradeSpy = sinon.spy(upgrader, 'upgradeOutbound')
+
+      await expect(transport.dial(addrs[1], {
+        upgrader
+      })).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, upgrader })
+
+      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, upgrader })
+      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,25 @@
+import { expect } from 'aegir/chai'
+import type { TransportTestFixtures } from './index.js'
+import type { TestSetup } from '../index.js'
+import type { Transport } from '@libp2p/interface/transport'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+export default (common: TestSetup<TransportTestFixtures>): void => {
+  describe('filter', () => {
+    let addrs: Multiaddr[]
+    let transport: Transport
+
+    before(async () => {
+      ({ addrs, transport } = await common.setup())
+    })
+
+    after(async () => {
+      await common.teardown()
+    })
+
+    it('filters addresses', () => {
+      const filteredAddrs = transport.filter(addrs)
+      expect(filteredAddrs).to.eql(addrs)
+    })
+  })
+}

package/src/transport/index.ts

@@ -0,0 +1,25 @@
+import dial from './dial-test.js'
+import filter from './filter-test.js'
+import listen from './listen-test.js'
+import type { TestSetup } from '../index.js'
+import type { Transport } from '@libp2p/interface/transport'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+export interface Connector {
+  delay: (ms: number) => void
+  restore: () => void
+}
+
+export interface TransportTestFixtures {
+  addrs: Multiaddr[]
+  transport: Transport
+  connector: Connector
+}
+
+export default (common: TestSetup<TransportTestFixtures>): void => {
+  describe('interface-transport', () => {
+    dial(common)
+    listen(common)
+    filter(common)
+  })
+}

package/src/transport/listen-test.ts

@@ -0,0 +1,191 @@
+/* eslint max-nested-callbacks: ["error", 8] */
+import { CustomEvent, EventEmitter } from '@libp2p/interface/events'
+import { expect } from 'aegir/chai'
+import drain from 'it-drain'
+import { pipe } from 'it-pipe'
+import defer from 'p-defer'
+import pWaitFor from 'p-wait-for'
+import sinon from 'sinon'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { isValidTick } from '../is-valid-tick.js'
+import { mockUpgrader, mockRegistrar } from '../mocks/index.js'
+import type { TransportTestFixtures } from './index.js'
+import type { TestSetup } from '../index.js'
+import type { Connection } from '@libp2p/interface/connection'
+import type { Transport, Upgrader } from '@libp2p/interface/transport'
+import type { Registrar } from '@libp2p/interface-internal/registrar'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+export default (common: TestSetup<TransportTestFixtures>): void => {
+  describe('listen', () => {
+    let upgrader: Upgrader
+    let addrs: Multiaddr[]
+    let transport: Transport
+    let registrar: Registrar
+
+    before(async () => {
+      registrar = mockRegistrar()
+      upgrader = mockUpgrader({
+        registrar,
+        events: new EventEmitter()
+      });
+
+      ({ transport, addrs } = await common.setup())
+    })
+
+    after(async () => {
+      await common.teardown()
+    })
+
+    afterEach(() => {
+      sinon.restore()
+    })
+
+    it('simple', async () => {
+      const listener = transport.createListener({
+        upgrader
+      })
+      await listener.listen(addrs[0])
+      await listener.close()
+    })
+
+    it('close listener with connections, through timeout', async () => {
+      const upgradeSpy = sinon.spy(upgrader, 'upgradeInbound')
+      const listenerConns: Connection[] = []
+
+      const protocol = '/test/protocol'
+      void registrar.handle(protocol, (data) => {
+        void drain(data.stream.source)
+      })
+
+      const listener = transport.createListener({
+        upgrader,
+        handler: (conn) => {
+          listenerConns.push(conn)
+        }
+      })
+
+      // Listen
+      await listener.listen(addrs[0])
+
+      // Create two connections to the listener
+      const [conn1] = await Promise.all([
+        transport.dial(addrs[0], {
+          upgrader
+        }),
+        transport.dial(addrs[0], {
+          upgrader
+        })
+      ])
+
+      // Give the listener a chance to finish its upgrade
+      await pWaitFor(() => listenerConns.length === 2)
+
+      const stream1 = await conn1.newStream([protocol])
+
+      // Wait for the data send and close to finish
+      await Promise.all([
+        pipe(
+          [uint8ArrayFromString('Some data that is never handled')],
+          stream1
+        ),
+        // Closer the listener (will take a couple of seconds to time out)
+        listener.close()
+      ])
+
+      await stream1.close()
+      await conn1.close()
+
+      expect(isValidTick(conn1.timeline.close)).to.equal(true)
+      listenerConns.forEach(conn => {
+        expect(isValidTick(conn.timeline.close)).to.equal(true)
+      })
+
+      // 2 dials = 2 connections upgraded
+      expect(upgradeSpy.callCount).to.equal(2)
+    })
+
+    it('should not handle connection if upgradeInbound throws', async () => {
+      sinon.stub(upgrader, 'upgradeInbound').throws()
+
+      const listener = transport.createListener({
+        upgrader
+      })
+
+      // Listen
+      await listener.listen(addrs[0])
+
+      // Create a connection to the listener
+      const conn = await transport.dial(addrs[0], {
+        upgrader
+      })
+
+      await pWaitFor(() => typeof conn.timeline.close === 'number')
+      await listener.close()
+    })
+
+    describe('events', () => {
+      it('connection', async () => {
+        const upgradeSpy = sinon.spy(upgrader, 'upgradeInbound')
+        const listener = transport.createListener({
+          upgrader
+        })
+        const deferred = defer()
+        let conn
+
+        listener.addEventListener('connection', (evt) => {
+          conn = evt.detail
+          deferred.resolve()
+        })
+
+        void (async () => {
+          await listener.listen(addrs[0])
+          await transport.dial(addrs[0], {
+            upgrader
+          })
+        })()
+
+        await deferred.promise
+
+        await expect(upgradeSpy.getCall(0).returnValue).to.eventually.equal(conn)
+        expect(upgradeSpy.callCount).to.equal(1)
+        await listener.close()
+      })
+
+      it('listening', (done) => {
+        const listener = transport.createListener({
+          upgrader
+        })
+        listener.addEventListener('listening', () => {
+          listener.close().then(done, done)
+        })
+        void listener.listen(addrs[0])
+      })
+
+      it('error', (done) => {
+        const listener = transport.createListener({
+          upgrader
+        })
+        listener.addEventListener('error', (evt) => {
+          expect(evt.detail).to.be.an.instanceOf(Error)
+          listener.close().then(done, done)
+        })
+        listener.dispatchEvent(new CustomEvent('error', {
+          detail: new Error('my err')
+        }))
+      })
+
+      it('close', (done) => {
+        const listener = transport.createListener({
+          upgrader
+        })
+        listener.addEventListener('close', () => { done() })
+
+        void (async () => {
+          await listener.listen(addrs[0])
+          await listener.close()
+        })()
+      })
+    })
+  })
+}

package/dist/typedoc-urls.json

@@ -1,3 +0,0 @@
-{
-  "TestSetup": "https://libp2p.github.io/js-libp2p-interfaces/interfaces/_libp2p_interface_compliance_tests.TestSetup.html"
-}