@libp2p/interface-compliance-tests 3.0.7 → 4.0.0

package/src/pubsub/utils.ts

@@ -0,0 +1,29 @@
+import { EventEmitter } from '@libp2p/interface/events'
+import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+import { pEvent } from 'p-event'
+import pWaitFor from 'p-wait-for'
+import { mockConnectionManager, mockRegistrar, mockNetwork } from '../mocks/index.js'
+import type { MockNetworkComponents } from '../mocks/index.js'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PubSub, SubscriptionChangeData } from '@libp2p/interface/pubsub'
+
+export async function waitForSubscriptionUpdate (a: PubSub, b: PeerId): Promise<void> {
+  await pWaitFor(async () => {
+    const event = await pEvent<'subscription-change', CustomEvent<SubscriptionChangeData>>(a, 'subscription-change')
+
+    return event.detail.peerId.equals(b)
+  })
+}
+
+export async function createComponents (): Promise<MockNetworkComponents> {
+  const components: any = {
+    peerId: await createEd25519PeerId(),
+    registrar: mockRegistrar(),
+    events: new EventEmitter()
+  }
+  components.connectionManager = mockConnectionManager(components)
+
+  mockNetwork.addNode(components)
+
+  return components
+}

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.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({
+        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.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({
+        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,442 @@
+/* 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 { pbStream } from 'it-protobuf-stream'
+import toBuffer from 'it-to-buffer'
+import pDefer from 'p-defer'
+import { Uint8ArrayList } from 'uint8arraylist'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { Message } from './fixtures/pb/message.js'
+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 close the dialer
+      await delay(50)
+      await pipe([], 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)
+
+      await 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.abort(new Error('Oh no!'))
+
+      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' })
+
+      await 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
+            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([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('code', 'ERR_SINK_INVALID_STATE')
+    })
+
+    it('can close a stream for reading', async () => {
+      const deferred = pDefer<Uint8ArrayList[]>()
+      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 expected = toBuffer(data.map(d => d.subarray()))
+
+      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()
+      await 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(toBuffer(results.map(b => b.subarray()))).to.equalBytes(expected)
+    })
+
+    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()
+
+      await 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()
+
+      await stream.closeWrite()
+      await stream.closeRead()
+      await deferred.promise
+    })
+
+    it('should wait for all data to be sent when closing streams', async () => {
+      const deferred = pDefer<Message>()
+
+      const p = duplexPair<Uint8Array>()
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer({ direction: 'outbound' })
+
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer({
+        direction: 'inbound',
+        onIncomingStream: (stream) => {
+          const pb = pbStream(stream)
+
+          void pb.read(Message)
+            .then(async message => {
+              deferred.resolve(message)
+              await pb.unwrap().close()
+            })
+            .catch(err => {
+              deferred.reject(err)
+            })
+        }
+      })
+
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
+
+      const message = {
+        message: 'hello world',
+        value: 5,
+        flag: true
+      }
+
+      const stream = await dialer.newStream()
+
+      const pb = pbStream(stream)
+      await pb.write(message, Message)
+      await pb.unwrap().close()
+
+      await expect(deferred.promise).to.eventually.deep.equal(message)
+    })
+    /*
+    it('should abort closing a stream with outstanding data to read', async () => {
+      const deferred = pDefer<Message>()
+
+      const p = duplexPair<Uint8Array>()
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer({ direction: 'outbound' })
+
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer({
+        direction: 'inbound',
+        onIncomingStream: (stream) => {
+          const pb = pbStream(stream)
+
+          void pb.read(Message)
+            .then(async message => {
+              await pb.write(message, Message)
+              await pb.unwrap().close()
+              deferred.resolve(message)
+            })
+            .catch(err => {
+              deferred.reject(err)
+            })
+        }
+      })
+
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
+
+      const message = {
+        message: 'hello world',
+        value: 5,
+        flag: true
+      }
+
+      const stream = await dialer.newStream()
+
+      const pb = pbStream(stream)
+      await pb.write(message, Message)
+
+      console.info('await write back')
+      await deferred.promise
+
+      // let message arrive
+      await delay(100)
+
+      // close should time out as message is never read
+      await expect(pb.unwrap().close()).to.eventually.be.rejected
+        .with.property('code', 'ERR_CLOSE_READ_ABORTED')
+    })
+    */
+  })
+}

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

@@ -0,0 +1,7 @@
+syntax = "proto3";
+
+message Message {
+  string message = 1;
+  uint32 value = 2;
+  bool flag = 3;
+}