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

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

@@ -1,80 +1,104 @@
 /* eslint max-nested-callbacks: ["error", 8] */
-import { multiaddrConnectionPair, echo, pbStream } from '@libp2p/utils'
+import { abortableSource } from 'abortable-iterator'
 import { expect } from 'aegir/chai'
 import delay from 'delay'
 import all from 'it-all'
-import map from 'it-map'
-import { pEvent } from 'p-event'
+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 { MultiaddrConnection, Stream, StreamMuxer, StreamMuxerFactory } from '@libp2p/interface'
+import type { StreamMuxerFactory } from '@libp2p/interface'
 
 function randomBuffer (): Uint8Array {
   return uint8ArrayFromString(Math.random().toString())
 }
 
-async function * infiniteRandom (): AsyncGenerator<Uint8ArrayList, void, unknown> {
-  while (true) {
-    await delay(10)
-    yield new Uint8ArrayList(randomBuffer())
-  }
-}
+function infiniteRandom (): AsyncGenerator<Uint8ArrayList, void, unknown> {
+  let done: Error | boolean = false
 
-export default (common: TestSetup<StreamMuxerFactory>): void => {
-  describe('close', () => {
-    let outboundConnection: MultiaddrConnection
-    let inboundConnection: MultiaddrConnection
-    let dialer: StreamMuxer
-    let listener: StreamMuxer
+  const generator: AsyncGenerator<Uint8ArrayList, void, unknown> = {
+    [Symbol.asyncIterator]: () => {
+      return generator
+    },
+    async next () {
+      await delay(10)
 
-    beforeEach(async () => {
-      [outboundConnection, inboundConnection] = multiaddrConnectionPair()
+      if (done instanceof Error) {
+        throw done
+      }
 
-      const dialerFactory = await common.setup()
-      dialer = dialerFactory.createStreamMuxer(outboundConnection)
+      if (done) {
+        return {
+          done: true,
+          value: undefined
+        }
+      }
 
-      const listenerFactory = await common.setup()
-      listener = listenerFactory.createStreamMuxer(inboundConnection)
-    })
+      return {
+        done: false,
+        value: new Uint8ArrayList(randomBuffer())
+      }
+    },
+    async return (): Promise<IteratorReturnResult<void>> {
+      done = true
 
-    afterEach(async () => {
-      await dialer?.close()
-      await listener?.close()
-    })
+      return {
+        done: true,
+        value: undefined
+      }
+    },
+    async throw (err: Error): Promise<IteratorReturnResult<void>> {
+      done = err
+
+      return {
+        done: true,
+        value: undefined
+      }
+    }
+  }
 
-    it('closing underlying MultiaddrConnection closes streams', async () => {
+  return generator
+}
+
+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.addEventListener('stream', (evt) => {
-        openedStreams++
-
-        echo(evt.detail)
+      // Listener is echo server :)
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer({
+        direction: 'inbound',
+        onIncomingStream: (stream) => {
+          openedStreams++
+          void pipe(stream, stream)
+        }
       })
 
-      const streams = await Promise.all(
-        Array(expectedStreams).fill(0).map(async () => dialer.createStream())
-      )
+      const p = duplexPair<Uint8Array | Uint8ArrayList>()
+      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 => {
-          for await (const buf of infiniteRandom()) {
-            if (stream.status !== 'open') {
-              return
-            }
-
-            const sendMore = stream.send(buf)
-
-            if (!sendMore) {
-              await pEvent(stream, 'drain', {
-                rejectionEvents: [
-                  'close'
-                ]
-              })
-            }
-          }
+          await pipe(
+            infiniteRandom(),
+            stream,
+            drain
+          )
         })
       )
 
@@ -82,9 +106,7 @@ export default (common: TestSetup<StreamMuxerFactory>): void => {
 
       // Pause, and then close the dialer
       await delay(50)
-      await inboundConnection.close()
-      await outboundConnection.close()
-      await delay(50)
+      await pipe(async function * () {}, dialer, drain)
 
       expect(openedStreams).to.have.equal(expectedStreams)
       expect(dialer.streams).to.have.lengthOf(0)
@@ -93,37 +115,36 @@ export default (common: TestSetup<StreamMuxerFactory>): void => {
     it('calling close closes streams', async () => {
       let openedStreams = 0
       const expectedStreams = 5
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer({
+        direction: 'outbound'
+      })
 
-      listener.addEventListener('stream', (evt) => {
-        openedStreams++
-
-        echo(evt.detail)
+      // Listener is echo server :)
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer({
+        direction: 'inbound',
+        onIncomingStream: (stream) => {
+          openedStreams++
+          void pipe(stream, stream).catch(() => {})
+        }
       })
 
-      const streams = await Promise.all(Array(expectedStreams).fill(0).map(async () => dialer.createStream()))
+      const p = duplexPair<Uint8Array | Uint8ArrayList>()
+      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 => {
-          for await (const buf of infiniteRandom()) {
-            if (stream.status !== 'open') {
-              return
-            }
-
-            const sendMore = stream.send(buf)
-
-            if (!sendMore) {
-              await pEvent(stream, 'drain', {
-                rejectionEvents: [
-                  'close'
-                ]
-              })
-            }
-          }
+          await pipe(
+            infiniteRandom(),
+            stream,
+            drain
+          )
         })
       )
-        .catch(() => {
-          // calling .send on a closed stream will throw so swallow any errors
-        })
 
       expect(dialer.streams, 'dialer - number of opened streams should match number of calls to newStream').to.have.lengthOf(expectedStreams)
 
@@ -132,328 +153,346 @@ export default (common: TestSetup<StreamMuxerFactory>): void => {
 
       await dialer.close()
 
-      await delay(50)
-
       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 abort aborts streams', async () => {
+    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.addEventListener('stream', (evt) => {
-        openedStreams++
-
-        echo(evt.detail)
+      // Listener is echo server :)
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer({
+        direction: 'inbound',
+        onIncomingStream: (stream) => {
+          openedStreams++
+          void pipe(stream, stream).catch(() => {})
+        }
       })
 
-      const streams = await Promise.all(
-        Array(expectedStreams).fill(0).map(async () => dialer.createStream())
-      )
+      const p = duplexPair<Uint8Array | Uint8ArrayList>()
+      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 => {
-        for await (const buf of infiniteRandom()) {
-          if (stream.writeStatus !== 'writable') {
-            break
-          }
+        await pipe(
+          infiniteRandom(),
+          stream,
+          drain
+        )
+      })
 
-          const sendMore = stream.send(buf)
+      expect(dialer.streams, 'dialer - number of opened streams should match number of calls to newStream').to.have.lengthOf(expectedStreams)
 
-          if (!sendMore) {
-            await pEvent(stream, 'drain', {
-              rejectionEvents: ['close']
-            })
-          }
-        }
-      })
+      // Pause, and then close the dialer
+      await delay(50)
 
-      expect(dialer.streams).to.have.lengthOf(expectedStreams, 'dialer - number of opened streams should match number of calls to createStream')
+      // close _with an error_
+      dialer.abort(new Error('Oh no!'))
 
       const timeoutError = new Error('timeout')
-
-      await Promise.all([
-        // Pause, and then close the dialer
-        delay(50).then(() => {
-          // close _with an error_
-          dialer.abort(new Error('Oh no!'))
-        }),
-        ...streamPipes.map(async pipe => {
-          try {
-            await Promise.race([
-              pipe,
-              new Promise((resolve, reject) => {
-                setTimeout(() => {
-                  reject(timeoutError)
-                }, 70)
-              })
-            ])
-            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')
-            }
+      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).to.equal(expectedStreams, 'listener - number of opened streams should match number of calls to createStream')
-      expect(dialer.streams).to.have.lengthOf(0, 'all tracked streams should be deleted after the muxer has called 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 newStream after close throws an error', async () => {
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer({
+        direction: 'outbound'
+      })
+
       await dialer.close()
-      await expect(dialer.createStream()).to.eventually.rejected.with.property('name', 'MuxerClosedError')
-      expect(dialer.streams).to.have.lengthOf(0, 'closed muxer should have no streams')
+
+      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 streamCount = 5
-      const allStreamsOpen = Promise.withResolvers<void>()
-
-      listener.addEventListener('stream', (evt) => {
-        echo(evt.detail).catch(() => {})
+      const p = duplexPair<Uint8Array | Uint8ArrayList>()
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer({
+        direction: 'outbound'
+      })
 
-        if (listener.streams.length === streamCount) {
-          allStreamsOpen.resolve()
+      // Listener is echo server :)
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer({
+        direction: 'inbound',
+        onIncomingStream: (stream) => {
+          void pipe(stream, stream).catch(() => {})
         }
       })
 
-      const streams = await Promise.all(
-        Array.from(Array(streamCount), async () => dialer.createStream())
-      )
-      await allStreamsOpen.promise
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
 
-      expect(dialer.streams).to.have.lengthOf(streamCount)
-      expect(listener.streams).to.have.lengthOf(streamCount)
+      const stream = await dialer.newStream()
+      const streams = await Promise.all(Array.from(Array(5), async () => dialer.newStream()))
+      let closed = false
+      const controllers: AbortController[] = []
 
-      expect(dialer.streams.map(s => s.status)).to.deep.equal(new Array(streamCount).fill('open'))
-      expect(listener.streams.map(s => s.status)).to.deep.equal(new Array(streamCount).fill('open'))
+      const streamResults = streams.map(async stream => {
+        const controller = new AbortController()
+        controllers.push(controller)
 
-      const localStream = streams[0]
-      const remoteStream = listener.streams[0]
+        try {
+          const abortableRand = abortableSource(infiniteRandom(), controller.signal, {
+            abortName: 'TestAbortError'
+          })
+          await pipe(abortableRand, stream, drain)
+        } catch (err: any) {
+          if (err.name !== 'TestAbortError') { throw err }
+        }
+
+        if (!closed) { throw new Error('stream should not have ended yet!') }
+      })
 
-      await Promise.all([
-        pEvent(remoteStream, 'close'),
-        pEvent(localStream, 'close'),
-        localStream.close()
-      ])
+      // Pause, and then send some data and close the first stream
+      await delay(50)
+      await pipe([new Uint8ArrayList(randomBuffer())], stream, drain)
+      closed = true
 
-      expect(dialer.streams).to.have.lengthOf(streamCount - 1)
-      expect(listener.streams).to.have.lengthOf(streamCount - 1)
+      // Abort all the other streams later
+      await delay(50)
+      controllers.forEach(c => { c.abort() })
 
-      expect(dialer.streams.map(s => s.status)).to.deep.equal(new Array(streamCount - 1).fill('open'))
-      expect(listener.streams.map(s => s.status)).to.deep.equal(new Array(streamCount - 1).fill('open'))
+      // These should now all resolve without error
+      await Promise.all(streamResults)
     })
 
     it('can close a stream for writing', async () => {
-      const deferred = Promise.withResolvers<Error>()
-      const data = [Uint8Array.from([0, 1, 2, 3, 4]), Uint8Array.from([5, 6, 7, 8, 9])]
+      const deferred = pDefer<Error>()
+
+      const p = duplexPair<Uint8Array | Uint8ArrayList>()
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer({
+        direction: 'outbound'
+      })
+      const data = [randomBuffer(), randomBuffer()]
 
-      listener.addEventListener('stream', (evt) => {
-        void Promise.resolve().then(async () => {
-          try {
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer({
+        direction: 'inbound',
+        onIncomingStream: (stream) => {
+          void Promise.resolve().then(async () => {
             // Immediate close for write
-            await evt.detail.close({
-              signal: AbortSignal.timeout(1_000)
+            await stream.closeWrite()
+
+            const results = await pipe(stream, async (source) => {
+              const data = []
+              for await (const chunk of source) {
+                data.push(chunk.slice())
+              }
+              return data
             })
-
-            const results = await all(map(evt.detail, (buf) => {
-              return buf.subarray()
-            }))
-
-            expect(results).to.deep.equal(data)
+            expect(results).to.eql(data)
 
             try {
-              evt.detail.send(randomBuffer())
+              await stream.sink([new Uint8ArrayList(randomBuffer())])
             } catch (err: any) {
               deferred.resolve(err)
             }
 
-            throw new Error('should not support writing to closed writer')
-          } catch (err) {
-            deferred.reject(err)
-          }
-        })
-      })
-
-      const stream = await dialer.createStream()
-
-      for (const buf of data) {
-        if (!stream.send(buf)) {
-          await pEvent(stream, 'drain', {
-            rejectionEvents: [
-              'close'
-            ]
+            deferred.reject(new Error('should not support writing to closed writer'))
           })
         }
-      }
-
-      await stream.close({
-        signal: AbortSignal.timeout(1_000)
       })
 
+      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('name', 'StreamStateError')
     })
 
-    it('should emit a close event for closed streams not previously written', async () => {
-      listener.addEventListener('stream', async (evt) => {
-        void evt.detail.close()
+    it('can close a stream for reading', async () => {
+      const deferred = pDefer<Uint8ArrayList[]>()
+      const p = duplexPair<Uint8Array | Uint8ArrayList>()
+      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 deferred = Promise.withResolvers<void>()
-      const stream = await dialer.createStream()
-      stream.addEventListener('close', () => {
-        deferred.resolve()
+      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('should emit a close event for aborted streams not previously written', async () => {
-      const deferred = Promise.withResolvers<void>()
-      const stream = await dialer.createStream()
-      stream.addEventListener('close', () => {
-        deferred.resolve()
+    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
       })
 
-      stream.abort(new Error('Urk!'))
+      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 = Promise.withResolvers<Message>()
+      const deferred = pDefer<Message>()
 
-      listener.addEventListener('stream', (evt) => {
-        const pb = pbStream(evt.detail)
+      const p = duplexPair<Uint8Array | Uint8ArrayList>()
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer({
+        direction: 'outbound'
+      })
 
-        void pb.read(Message)
-          .then(async message => {
-            deferred.resolve(message)
-            await evt.detail.close()
-          })
-          .catch(err => {
-            deferred.reject(err)
-          })
+      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.createStream()
+      const stream = await dialer.newStream()
 
       const pb = pbStream(stream)
       await pb.write(message, Message)
-      await stream.close()
+      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>()
 
-    it('should remove a stream in the streams list after aborting', async () => {
-      const [
-        listenerStream,
-        dialerStream
-      ] = await Promise.all([
-        pEvent<'stream', CustomEvent<Stream>>(listener, 'stream').then(evt => evt.detail),
-        dialer.createStream()
-      ])
-
-      expect(dialer.streams).to.include(dialerStream, 'dialer did not store outbound stream')
-      expect(listener.streams).to.include(listenerStream, 'listener did not store inbound stream')
-
-      await Promise.all([
-        pEvent(listenerStream, 'close'),
-        dialerStream.abort(new Error('Urk!'))
-      ])
-
-      expect(dialer.streams).to.not.include(dialerStream, 'dialer did not remove outbound stream close')
-      expect(listener.streams).to.not.include(listenerStream, 'listener did not remove inbound stream after close')
-    })
-
-    it('should remove a stream in the streams list after closing', async () => {
-      const [
-        listenerStream,
-        dialerStream
-      ] = await Promise.all([
-        pEvent<'stream', CustomEvent<Stream>>(listener, 'stream').then(evt => evt.detail),
-        dialer.createStream()
-      ])
-
-      expect(dialer.streams).to.include(dialerStream, 'dialer did not store outbound stream')
-      expect(listener.streams).to.include(listenerStream, 'listener did not store inbound stream')
-
-      await Promise.all([
-        dialerStream.close(),
-        listenerStream.close()
-      ])
-
-      await delay(10)
-
-      expect(dialer.streams).to.not.include(dialerStream, 'dialer did not remove outbound stream close')
-      expect(listener.streams).to.not.include(listenerStream, 'listener did not remove inbound stream after close')
-    })
-
-    it('should not remove a half-closed outbound stream', async () => {
-      const [
-        listenerStream,
-        dialerStream
-      ] = await Promise.all([
-        pEvent<'stream', CustomEvent<Stream>>(listener, 'stream').then(evt => evt.detail),
-        dialer.createStream()
-      ])
-
-      await dialerStream.close()
-
-      expect(dialer.streams).to.include(dialerStream, 'dialer did not store outbound stream')
-      expect(listener.streams).to.include(listenerStream, 'listener did not store inbound stream')
-    })
-
-    it('should not remove a half-closed inbound stream', async () => {
-      const [
-        listenerStream,
-        dialerStream
-      ] = await Promise.all([
-        pEvent<'stream', CustomEvent<Stream>>(listener, 'stream').then(evt => evt.detail),
-        dialer.createStream()
-      ])
-
-      await listenerStream.close()
+      const p = duplexPair<Uint8Array | Uint8ArrayList>()
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer({ direction: 'outbound' })
 
-      expect(dialer.streams).to.include(dialerStream, 'dialer did not store outbound stream')
-      expect(listener.streams).to.include(listenerStream, 'listener did not store inbound stream')
-    })
+      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)
+            })
+        }
+      })
 
-    it('should remove a stream half closed from both ends', async () => {
-      const [
-        listenerStream,
-        dialerStream
-      ] = await Promise.all([
-        pEvent<'stream', CustomEvent<Stream>>(listener, 'stream').then(evt => evt.detail),
-        dialer.createStream()
-      ])
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
 
-      expect(dialer.streams).to.include(dialerStream, 'dialer did not store outbound stream')
-      expect(listener.streams).to.include(listenerStream, 'listener did not store inbound stream')
+      const message = {
+        message: 'hello world',
+        value: 5,
+        flag: true
+      }
 
-      await listenerStream.close()
+      const stream = await dialer.newStream()
 
-      expect(dialer.streams).to.include(dialerStream, 'dialer removed outbound stream before fully closing')
-      expect(listener.streams).to.include(listenerStream, 'listener removed inbound stream before fully closing')
+      const pb = pbStream(stream)
+      await pb.write(message, Message)
 
-      await Promise.all([
-        pEvent(listenerStream, 'close'),
-        dialerStream.close()
-      ])
+      console.info('await write back')
+      await deferred.promise
 
-      await delay(10)
+      // let message arrive
+      await delay(100)
 
-      expect(dialer.streams).to.not.include(dialerStream, 'dialer did not remove outbound stream close')
-      expect(listener.streams).to.not.include(listenerStream, 'listener did not remove inbound stream after close')
+      // close should time out as message is never read
+      await expect(pb.unwrap().close()).to.eventually.be.rejected
+        .with.property('name', 'TimeoutError')
     })
+    */
   })
 }