@libp2p/interface-compliance-tests 6.5.0 → 7.0.0-55b7e5fea

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

@@ -1,458 +1,120 @@
+import { multiaddrConnectionPair, byteStream } from '@libp2p/utils'
 import { expect } from 'aegir/chai'
-import all from 'it-all'
-import { byteStream } from 'it-byte-stream'
-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 { pEvent } from 'p-event'
 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, StreamMuxerFactory } from '@libp2p/interface'
-import type { Source } from 'it-stream-types'
-import type { DeferredPromise } from 'p-defer'
+import type { Stream, StreamMuxer, StreamMuxerFactory } from '@libp2p/interface'
 
 export default (common: TestSetup<StreamMuxerFactory>): void => {
   describe('base', () => {
-    it('should open a stream from the dialer', async () => {
-      const p = duplexPair<Uint8Array | Uint8ArrayList>()
-      const onStreamPromise: DeferredPromise<Stream> = defer()
-      const onStreamEndPromise: DeferredPromise<Stream> = defer()
+    let dialer: StreamMuxer
+    let listener: StreamMuxer
+
+    beforeEach(async () => {
+      const [outboundConnection, inboundConnection] = multiaddrConnectionPair()
 
       const dialerFactory = await common.setup()
-      const dialer = dialerFactory.createStreamMuxer({
-        direction: 'outbound'
-      })
+      dialer = dialerFactory.createStreamMuxer(outboundConnection)
 
       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 dialerStream = await dialer.newStream()
-      expect(dialer.streams).to.include(dialerStream)
-      expect(isValidTick(dialerStream.timeline.open)).to.equal(true)
-
-      const dialerBytes = byteStream(dialerStream)
-      void dialerBytes.write(uint8ArrayFromString('hello'))
+      listener = listenerFactory.createStreamMuxer(inboundConnection)
+    })
 
-      const listenerStream = await onStreamPromise.promise
-      expect(isValidTick(listenerStream.timeline.open)).to.equal(true)
-      // Make sure the stream is being tracked
-      expect(listener.streams).to.include(listenerStream)
+    afterEach(async () => {
+      await dialer?.close()
+      await listener?.close()
+    })
 
-      await dialerStream.close()
-      await listenerStream.close()
+    it('should have a protocol', async () => {
+      expect(dialer.protocol).to.be.a('string')
+    })
 
-      // Make sure stream is closed properly
-      const endedStream = await onStreamEndPromise.promise
-      expect(listener.streams).to.not.include(endedStream)
+    it('should be open', async () => {
+      expect(dialer.status).to.equal('open')
+    })
 
-      if (endedStream.timeline.close == null) {
-        throw new Error('timeline had no close time')
-      }
+    it('should be closing during closing', async () => {
+      const closePromise = dialer.close()
+      expect(dialer.status).to.equal('closing')
 
-      // Make sure the stream is removed from tracking
-      expect(isValidTick(endedStream.timeline.close)).to.equal(true)
+      await closePromise
+    })
 
+    it('should be closed after closing', async () => {
       await dialer.close()
-      await listener.close()
 
-      // ensure we have no streams left
-      expect(dialer.streams).to.have.length(0)
-      expect(listener.streams).to.have.length(0)
+      expect(dialer.status).to.equal('closed')
     })
 
-    it('should open a stream from the listener', async () => {
-      const p = duplexPair<Uint8Array | Uint8ArrayList>()
-      const onStreamPromise: DeferredPromise<Stream> = defer()
-      const onStreamEndPromise: DeferredPromise<Stream> = defer()
-      const dialerFactory = await common.setup()
-      const dialer = dialerFactory.createStreamMuxer({
-        direction: 'outbound',
-        onIncomingStream: (stream: Stream) => {
-          onStreamPromise.resolve(stream)
-        },
-        onStreamEnd: (stream) => {
-          onStreamEndPromise.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])
+    it('should open a stream', async () => {
+      const [
+        listenerStream,
+        dialerStream
+      ] = await Promise.all([
+        pEvent<'stream', CustomEvent<Stream>>(listener, 'stream').then(evt => evt.detail),
+        dialer.createStream()
+      ])
 
-      const listenerStream = await listener.newStream()
+      const dialerBytes = byteStream(dialerStream)
       const listenerBytes = byteStream(listenerStream)
-      void listenerBytes.write(uint8ArrayFromString('hello'))
-
-      const dialerStream = await onStreamPromise.promise
 
-      expect(isValidTick(dialerStream.timeline.open)).to.equal(true)
-      expect(listener.streams).to.include(listenerStream)
-      expect(isValidTick(listenerStream.timeline.open)).to.equal(true)
+      const input = uint8ArrayFromString('hello')
 
-      await dialerStream.close()
-      await listenerStream.close()
-
-      // Make sure stream is closed properly
-      const endedStream = await onStreamEndPromise.promise
-      expect(dialer.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)
+      const [, output] = await Promise.all([
+        dialerBytes.write(input),
+        listenerBytes.read()
+      ])
 
-      await dialer.close()
-      await listener.close()
+      expect(output?.subarray()).to.equalBytes(input.subarray())
     })
 
     it('should open a stream on both sides', async () => {
-      const p = duplexPair<Uint8Array | Uint8ArrayList>()
-      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 [
+        listenerInboundStream,
+        dialerOutboundStream,
 
-      const dialerInitiatorStream = await dialer.newStream()
-      const listenerInitiatorStream = await listener.newStream()
+        dialerInboundStream,
+        listenerOutboundStream
+      ] = await Promise.all([
+        pEvent<'stream', CustomEvent<Stream>>(listener, 'stream').then(evt => evt.detail),
+        dialer.createStream(),
 
-      await Promise.all([
-        dialerInitiatorStream.close(),
-        listenerInitiatorStream.close(),
-        onDialerStreamPromise.promise.then(async stream => { await stream.close() }),
-        onListenerStreamPromise.promise.then(async stream => { await stream.close() })
+        pEvent<'stream', CustomEvent<Stream>>(dialer, 'stream').then(evt => evt.detail),
+        listener.createStream()
       ])
 
-      await Promise.all([
-        dialer.close(),
-        listener.close()
-      ])
-    })
+      const dialerOutboundBytes = byteStream(dialerOutboundStream)
+      const listenerInboundBytes = byteStream(listenerInboundStream)
 
-    it('should 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 | Uint8ArrayList>()
-      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 listenerOutboundBytes = byteStream(listenerOutboundStream)
+      const dialerInboundBytes = byteStream(dialerInboundStream)
 
-      const dialerConn = await dialer.newStream()
-      const listenerConn = await listener.newStream()
+      const inputA = uint8ArrayFromString('hello')
+      const inputB = uint8ArrayFromString('world')
 
-      void pipe([new Uint8ArrayList(uint8ArrayFromString('hey'))], dialerConn)
-      void pipe([new Uint8ArrayList(uint8ArrayFromString('hello'))], listenerConn)
+      const [, outputA] = await Promise.all([
+        dialerOutboundBytes.write(inputA),
+        listenerInboundBytes.read(),
 
-      const [
-        dialerStream,
-        listenerStream
-      ] = await Promise.all([
-        onDialerStreamPromise.promise,
-        onListenerStreamPromise.promise
+        listenerOutboundBytes.write(inputB),
+        dialerInboundBytes.read()
       ])
 
+      expect(outputA?.subarray()).to.equalBytes(inputA.subarray())
+      expect(inputB?.subarray()).to.equalBytes(inputB.subarray())
+    })
+
+    it('should store a stream in the streams list', async () => {
       const [
-        listenerChunks,
-        dialerChunks
+        listenerStream,
+        dialerStream
       ] = await Promise.all([
-        pipe(listenerStream, toString, async (source) => all(source)),
-        pipe(dialerStream, toString, async (source) => all(source))
+        pEvent<'stream', CustomEvent<Stream>>(listener, 'stream').then(evt => evt.detail),
+        dialer.createStream()
       ])
 
-      expect(listenerChunks).to.be.eql(['hey'])
-      expect(dialerChunks).to.be.eql(['hello'])
-    })
-
-    it('should echo a small value via a pipe', async () => {
-      const p = duplexPair<Uint8Array | Uint8ArrayList>()
-      const onDialerStreamPromise: DeferredPromise<Stream> = defer()
-      const onDataReceivedPromise: DeferredPromise<Uint8Array> = 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) => {
-          void Promise.resolve().then(async () => {
-            const output = new Uint8ArrayList()
-
-            for await (const buf of stream.source) {
-              output.append(buf)
-            }
-
-            onDataReceivedPromise.resolve(output.subarray())
-          })
-        }
-      })
-
-      void pipe(p[0], dialer, p[0])
-      void pipe(p[1], listener, p[1])
-
-      const stream = await dialer.newStream()
-      const input = Uint8Array.from([0, 1, 2, 3, 4])
-
-      await pipe(
-        [input],
-        stream
-      )
-      await stream.close()
-
-      expect(await onDataReceivedPromise.promise).to.equalBytes(input)
-    })
-
-    it('should echo a large value via a pipe', async () => {
-      const p = duplexPair<Uint8Array | Uint8ArrayList>()
-      const onDialerStreamPromise: DeferredPromise<Stream> = defer()
-      const onDataReceivedPromise: DeferredPromise<Uint8Array> = 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) => {
-          void Promise.resolve().then(async () => {
-            const output = new Uint8ArrayList()
-
-            for await (const buf of stream.source) {
-              output.append(buf)
-            }
-
-            onDataReceivedPromise.resolve(output.subarray())
-          })
-        }
-      })
-
-      void pipe(p[0], dialer, p[0])
-      void pipe(p[1], listener, p[1])
-
-      const stream = await dialer.newStream()
-      const input = Uint8Array.from(new Array(1024 * 1024 * 10).fill(0))
-
-      await pipe(
-        [input],
-        stream
-      )
-      await stream.close()
-
-      expect(await onDataReceivedPromise.promise).to.equalBytes(input)
-    })
-
-    it('should echo a small value via sink', async () => {
-      const p = duplexPair<Uint8Array | Uint8ArrayList>()
-      const onDialerStreamPromise: DeferredPromise<Stream> = defer()
-      const onDataReceivedPromise: DeferredPromise<Uint8Array> = 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) => {
-          void Promise.resolve().then(async () => {
-            const output = new Uint8ArrayList()
-
-            for await (const buf of stream.source) {
-              output.append(buf)
-            }
-
-            onDataReceivedPromise.resolve(output.subarray())
-          })
-        }
-      })
-
-      void pipe(p[0], dialer, p[0])
-      void pipe(p[1], listener, p[1])
-
-      const stream = await dialer.newStream()
-      const input = Uint8Array.from([0, 1, 2, 3, 4])
-
-      await stream.sink([input])
-      await stream.close()
-
-      expect(await onDataReceivedPromise.promise).to.equalBytes(input)
-    })
-
-    it('should echo a large value via sink', async () => {
-      const p = duplexPair<Uint8Array | Uint8ArrayList>()
-      const onDialerStreamPromise: DeferredPromise<Stream> = defer()
-      const onDataReceivedPromise: DeferredPromise<Uint8Array> = 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) => {
-          void Promise.resolve().then(async () => {
-            const output = new Uint8ArrayList()
-
-            for await (const buf of stream.source) {
-              output.append(buf)
-            }
-
-            onDataReceivedPromise.resolve(output.subarray())
-          })
-        }
-      })
-
-      void pipe(p[0], dialer, p[0])
-      void pipe(p[1], listener, p[1])
-
-      const stream = await dialer.newStream()
-      const input = Uint8Array.from(new Array(1024 * 1024 * 10).fill(0))
-
-      await stream.sink([input])
-      await stream.close()
-
-      expect(await onDataReceivedPromise.promise).to.equalBytes(input)
-    })
-
-    it('should echo a small value via a pushable', async () => {
-      const p = duplexPair<Uint8Array | Uint8ArrayList>()
-      const onDialerStreamPromise: DeferredPromise<Stream> = defer()
-      const onDataReceivedPromise: DeferredPromise<Uint8Array> = 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) => {
-          void Promise.resolve().then(async () => {
-            const output = new Uint8ArrayList()
-
-            for await (const buf of stream.source) {
-              output.append(buf)
-            }
-
-            onDataReceivedPromise.resolve(output.subarray())
-          })
-        }
-      })
-
-      void pipe(p[0], dialer, p[0])
-      void pipe(p[1], listener, p[1])
-
-      const stream = await dialer.newStream()
-      const input = Uint8Array.from([0, 1, 2, 3, 4])
-
-      const pushable = byteStream(stream)
-      await pushable.write(input)
-      await pushable.unwrap().close()
-
-      expect(await onDataReceivedPromise.promise).to.equalBytes(input)
-    })
-
-    it('should echo a large value via a pushable', async () => {
-      const p = duplexPair<Uint8Array | Uint8ArrayList>()
-      const onDialerStreamPromise: DeferredPromise<Stream> = defer()
-      const onDataReceivedPromise: DeferredPromise<Uint8Array> = 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) => {
-          void Promise.resolve().then(async () => {
-            const output = new Uint8ArrayList()
-
-            for await (const buf of stream.source) {
-              output.append(buf)
-            }
-
-            onDataReceivedPromise.resolve(output.subarray())
-          })
-        }
-      })
-
-      void pipe(p[0], dialer, p[0])
-      void pipe(p[1], listener, p[1])
-
-      const stream = await dialer.newStream()
-      const input = Uint8Array.from(new Array(1024 * 1024 * 10).fill(0))
-
-      const pushable = byteStream(stream)
-      await pushable.write(input)
-      await pushable.unwrap().close()
-
-      expect(await onDataReceivedPromise.promise).to.equalBytes(input)
+      expect(dialer.streams).to.include(dialerStream, 'dialer did not store outbound stream')
+      expect(listener.streams).to.include(listenerStream, 'listener did not store inbound stream')
     })
   })
 }