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

package/src/transport/index.ts

@@ -1,15 +1,13 @@
-import { stop, TimeoutError } from '@libp2p/interface'
-import { prefixLogger } from '@libp2p/logger'
+import { stop } from '@libp2p/interface'
 import { expect } from 'aegir/chai'
 import delay from 'delay'
-import all from 'it-all'
 import drain from 'it-drain'
 import { pushable } from 'it-pushable'
+import pDefer from 'p-defer'
 import { pEvent } from 'p-event'
 import pRetry from 'p-retry'
 import pWaitFor from 'p-wait-for'
 import { raceSignal } from 'race-signal'
-import { Uint8ArrayList } from 'uint8arraylist'
 import { isValidTick } from '../is-valid-tick.js'
 import { createPeer, getTransportManager, getUpgrader } from './utils.js'
 import type { TestSetup } from '../index.js'
@@ -18,6 +16,7 @@ import type { Connection, Libp2p, Stream, StreamHandler } from '@libp2p/interfac
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { MultiaddrMatcher } from '@multiformats/multiaddr-matcher'
 import type { Libp2pInit } from 'libp2p'
+import type { DeferredPromise } from 'p-defer'
 
 export interface TransportTestFixtures {
   /**
@@ -49,113 +48,34 @@ export interface TransportTestFixtures {
 
 async function getSetup (common: TestSetup<TransportTestFixtures>): Promise<{ dialer: Libp2p<{ echo: Echo }>, listener?: Libp2p<{ echo: Echo }>, dialAddrs: Multiaddr[], dialMultiaddrMatcher: MultiaddrMatcher, listenMultiaddrMatcher: MultiaddrMatcher }> {
   const setup = await common.setup()
-  const dialer = await createPeer({
-    logger: prefixLogger('dialer'),
-    ...setup.dialer
-  })
+  const dialer = await createPeer(setup.dialer)
   let listener
 
   if (setup.listener != null) {
-    listener = await createPeer({
-      logger: prefixLogger('listener'),
-      ...setup.listener
-    })
+    listener = await createPeer(setup.listener)
   }
 
-  let dialAddrs = listener?.getMultiaddrs() ?? setup.dialAddrs
+  const dialAddrs = listener?.getMultiaddrs() ?? setup.dialAddrs
 
   if (dialAddrs == null) {
     throw new Error('Listener config or dial addresses must be specified')
   }
 
-  dialAddrs = dialAddrs.filter(ma => setup.dialMultiaddrMatcher.exactMatch(ma))
-
-  if (dialAddrs.length === 0) {
-    throw new Error('Listener was not listening on any addresses that the dialMultiaddrMatcher matched')
-  }
-
   return {
     dialer,
     listener,
-    dialAddrs,
+    dialAddrs: dialAddrs.filter(ma => setup.dialMultiaddrMatcher.exactMatch(ma)),
     dialMultiaddrMatcher: setup.dialMultiaddrMatcher,
     listenMultiaddrMatcher: setup.listenMultiaddrMatcher
   }
 }
 
 export default (common: TestSetup<TransportTestFixtures>): void => {
-  describe('transport events', () => {
-    let dialer: Libp2p<{ echo: Echo }>
-    let listener: Libp2p<{ echo: Echo }> | undefined
-    let listenMultiaddrMatcher: MultiaddrMatcher
-
-    afterEach(async () => {
-      await stop(dialer, listener)
-      await common.teardown()
-    })
-
-    it('emits listening', async function () {
-      ({ dialer, listener, listenMultiaddrMatcher } = await getSetup(common))
-
-      if (listener == null) {
-        return this.skip()
-      }
-
-      await listener.stop()
-
-      const transportListeningPromise = Promise.withResolvers<void>()
-
-      listener.addEventListener('transport:listening', (event) => {
-        const transportListener = event.detail
-
-        if (transportListener.getAddrs().some(ma => listenMultiaddrMatcher.exactMatch(ma))) {
-          transportListeningPromise.resolve()
-        }
-      })
-
-      await listener.start()
-
-      await raceSignal(transportListeningPromise.promise, AbortSignal.timeout(1000), {
-        translateError: () => {
-          return new TimeoutError('Did not emit listening event')
-        }
-      })
-    })
-
-    it('emits close', async function () {
-      ({ dialer, listener } = await getSetup(common))
-
-      if (listener == null) {
-        return this.skip()
-      }
-
-      const transportManager = getTransportManager(listener)
-      const transportListener = transportManager.getListeners()
-        .filter(listener => listener.getAddrs().some(ma => listenMultiaddrMatcher.exactMatch(ma)))
-        .pop()
-
-      if (transportListener == null) {
-        throw new Error('Could not find address listener')
-      }
-
-      const p = pEvent(transportListener, 'close')
-
-      await listener.stop()
-
-      await raceSignal(p, AbortSignal.timeout(1000), {
-        translateError: () => {
-          return new TimeoutError('Did not emit close event')
-        }
-      })
-    })
-  })
-
   describe('interface-transport', () => {
     let dialer: Libp2p<{ echo: Echo }>
     let listener: Libp2p<{ echo: Echo }> | undefined
     let dialAddrs: Multiaddr[]
     let dialMultiaddrMatcher: MultiaddrMatcher
-    let listenMultiaddrMatcher: MultiaddrMatcher
 
     afterEach(async () => {
       await stop(dialer, listener)
@@ -170,7 +90,7 @@ export default (common: TestSetup<TransportTestFixtures>): void => {
         signal: AbortSignal.timeout(5000)
       })
 
-      expect(output.subarray()).to.equalBytes(input)
+      expect(output).to.equalBytes(input)
     })
 
     it('should listen on multiple addresses', async () => {
@@ -178,16 +98,13 @@ export default (common: TestSetup<TransportTestFixtures>): void => {
 
       const input = Uint8Array.from([0, 1, 2, 3, 4])
 
-      const output1 = await dialer.services.echo.echo(dialAddrs[0], input, {
+      await expect(dialer.services.echo.echo(dialAddrs[0], input, {
         signal: AbortSignal.timeout(5000)
-      })
-      expect(output1.subarray()).to.equalBytes(input)
+      })).to.eventually.deep.equal(input)
 
-      const output2 = await dialer.services.echo.echo(dialAddrs[1], input, {
-        signal: AbortSignal.timeout(5000),
-        force: true
-      })
-      expect(output2.subarray()).to.equalBytes(input)
+      await expect(dialer.services.echo.echo(dialAddrs[1], input, {
+        signal: AbortSignal.timeout(5000)
+      })).to.eventually.deep.equal(input)
     })
 
     it('can close connections', async () => {
@@ -214,20 +131,16 @@ export default (common: TestSetup<TransportTestFixtures>): void => {
     })
 
     it('should close all streams when the connection closes', async () => {
-      ({ dialer, listener, dialAddrs, listenMultiaddrMatcher } = await getSetup(common))
+      ({ dialer, listener, dialAddrs } = await getSetup(common))
 
-      let incomingConnectionPromise: PromiseWithResolvers<Connection> | undefined
+      let incomingConnectionPromise: DeferredPromise<Connection> | undefined
 
       if (listener != null) {
-        incomingConnectionPromise = Promise.withResolvers<Connection>()
+        incomingConnectionPromise = pDefer<Connection>()
 
         listener.addEventListener('connection:open', (event) => {
           const conn = event.detail
 
-          if (!listenMultiaddrMatcher.matches(conn.remoteAddr)) {
-            return
-          }
-
           if (conn.remotePeer.equals(dialer.peerId)) {
             incomingConnectionPromise?.resolve(conn)
           }
@@ -247,28 +160,22 @@ export default (common: TestSetup<TransportTestFixtures>): void => {
         })
       }
 
-      expect(connection).to.have.property('streams').that.has.lengthOf(5)
-
-      if (remoteConn != null) {
-        await pWaitFor(() => remoteConn.streams.length === 5, {
-          timeout: 5000
-        })
-      }
+      const streams = connection.streams
 
       // Close the connection and verify all streams have been closed
-      await Promise.all([
-        pEvent(connection, 'close'),
-        pEvent(remoteConn ?? connection, 'close'),
-        connection.close()
-      ])
+      await connection.close()
 
-      expect(connection).to.have.property('status', 'closed')
-      expect(connection).to.have.property('streams').that.is.empty()
+      await pWaitFor(() => connection.streams.length === 0, {
+        timeout: 5000
+      })
 
       if (remoteConn != null) {
-        expect(remoteConn).to.have.property('status', 'closed')
-        expect(remoteConn).to.have.property('streams').that.is.empty()
+        await pWaitFor(() => remoteConn.streams.length === 0, {
+          timeout: 5000
+        })
       }
+
+      expect(streams.find(stream => stream.status === 'open')).to.be.undefined()
     })
 
     it('should not handle connection if upgradeInbound rejects', async function () {
@@ -320,138 +227,189 @@ export default (common: TestSetup<TransportTestFixtures>): void => {
       }
     })
 
-    it('should handle one small write', async function () {
+    it('should handle one big write', async function () {
       const timeout = 120_000
       this.timeout(timeout);
       ({ dialer, listener, dialAddrs } = await getSetup(common))
 
-      const connection = await dialer.dial(dialAddrs[0])
-
-      const input = new Uint8Array(1024).fill(5)
-      const output = await dialer.services.echo.echo(connection.remotePeer, input, {
+      const input = new Uint8Array(1024 * 1024 * 10).fill(5)
+      const output = await dialer.services.echo.echo(dialAddrs[0], input, {
         signal: AbortSignal.timeout(timeout)
       })
 
-      expect(output.subarray()).to.equalBytes(input)
-      expect(connection.streams.filter(s => s.protocol === dialer.services.echo.protocol)).to.be.empty()
+      expect(output).to.equalBytes(input)
     })
 
-    it('should handle one big write', async function () {
-      const timeout = 540_000
+    it('should handle many small writes', async function () {
+      const timeout = 360_000
       this.timeout(timeout);
       ({ dialer, listener, dialAddrs } = await getSetup(common))
 
-      const connection = await dialer.dial(dialAddrs[0])
+      for (let i = 0; i < 2000; i++) {
+        const input = new Uint8Array(1024).fill(5)
+        const output = await dialer.services.echo.echo(dialAddrs[0], input, {
+          signal: AbortSignal.timeout(timeout)
+        })
 
-      const input = new Uint8Array(1024 * 1024 * 10).fill(5)
-      const output = await dialer.services.echo.echo(connection.remotePeer, input, {
-        signal: AbortSignal.timeout(timeout)
+        expect(output).to.equalBytes(input)
+      }
+    })
+
+    it('can close a stream for reading but send a large amount of data', async function () {
+      const timeout = 120_000
+      this.timeout(timeout);
+      ({ dialer, listener, dialAddrs } = await getSetup(common))
+
+      if (listener == null) {
+        return this.skip()
+      }
+
+      const protocol = '/send-data/1.0.0'
+      const chunkSize = 1024
+      const bytes = chunkSize * 1024 * 10
+      const deferred = pDefer()
+
+      await listener.handle(protocol, ({ stream }) => {
+        Promise.resolve().then(async () => {
+          let read = 0
+
+          for await (const buf of stream.source) {
+            read += buf.byteLength
+
+            if (read === bytes) {
+              deferred.resolve()
+              break
+            }
+          }
+        })
+          .catch(err => {
+            deferred.reject(err)
+            stream.abort(err)
+          })
       })
 
-      expect(output.subarray()).to.equalBytes(input)
-      expect(connection.streams.filter(s => s.protocol === dialer.services.echo.protocol)).to.be.empty()
+      const stream = await dialer.dialProtocol(dialAddrs[0], protocol)
+
+      await stream.closeRead()
+
+      await stream.sink((async function * () {
+        for (let i = 0; i < bytes; i += chunkSize) {
+          yield new Uint8Array(chunkSize)
+        }
+      })())
+
+      await stream.close()
+
+      await deferred.promise
     })
 
-    it('should handle many small writes', async function () {
-      const timeout = 360_000
+    it('can close a stream for writing but receive a large amount of data', async function () {
+      const timeout = 120_000
       this.timeout(timeout);
       ({ dialer, listener, dialAddrs } = await getSetup(common))
 
-      const connection = await dialer.dial(dialAddrs[0])
-      const echoProtocol = dialer.services.echo.protocol
+      if (listener == null) {
+        return this.skip()
+      }
 
-      for (let i = 0; i < 2000; i++) {
-        const input = new Uint8Array(1024).fill(5)
-        const output = await dialer.services.echo.echo(connection.remotePeer, input, {
-          signal: AbortSignal.timeout(timeout)
+      const protocol = '/receive-data/1.0.0'
+      const chunkSize = 1024
+      const bytes = chunkSize * 1024 * 10
+      const deferred = pDefer()
+
+      await listener.handle(protocol, ({ stream }) => {
+        Promise.resolve().then(async () => {
+          await stream.sink((async function * () {
+            for (let i = 0; i < bytes; i += chunkSize) {
+              yield new Uint8Array(chunkSize)
+            }
+          })())
+
+          await stream.close()
         })
+          .catch(err => {
+            deferred.reject(err)
+            stream.abort(err)
+          })
+      })
 
-        expect(output.subarray()).to.equalBytes(input)
-        expect(connection.streams.filter(s => s.protocol === echoProtocol)).to.be.empty()
+      const stream = await dialer.dialProtocol(dialAddrs[0], protocol)
+
+      await stream.closeWrite()
+
+      let read = 0
+
+      for await (const buf of stream.source) {
+        read += buf.byteLength
       }
+
+      expect(read).to.equal(bytes)
     })
 
-    it('can close local stream while a remote stream is writing', async function () {
+    it('can close local stream for writing and reading while a remote stream is writing', async function () {
       ({ dialer, listener, dialAddrs } = await getSetup(common))
 
       if (listener == null) {
         return this.skip()
       }
 
-      // 1. remote stream close read
-      // 2. local stream close write
-      // 3. remote stream close write
-
       /**
        * NodeA             NodeB
        * |   <--- STOP_SENDING |
        * | FIN --->            |
-       * |           <--- DATA |
        * |            <--- FIN |
        * | FIN_ACK --->        |
        * |        <--- FIN_ACK |
        */
 
-      const getRemoteStream = Promise.withResolvers<Stream>()
+      const getRemoteStream = pDefer<Stream>()
       const protocol = '/close-local-while-remote-writes/1.0.0'
 
-      const streamHandler: StreamHandler = (stream) => {
-        getRemoteStream.resolve(stream)
+      const streamHandler: StreamHandler = ({ stream }) => {
+        void Promise.resolve().then(async () => {
+          getRemoteStream.resolve(stream)
+        })
       }
 
-      await listener.handle(protocol, streamHandler, {
+      await listener.handle(protocol, (info) => {
+        streamHandler(info)
+      }, {
         runOnLimitedConnection: true
       })
 
       const connection = await dialer.dial(dialAddrs[0])
 
-      const [
-        localStream,
-        remoteStream
-      ] = await Promise.all([
-        // open a stream on the echo protocol
-        connection.newStream(protocol, {
-          runOnLimitedConnection: true
-        }),
-        getRemoteStream.promise
-      ])
-
-      // ignore incoming data
-      void drain(localStream)
-
-      // close the remote readable end
+      // open a stream on the echo protocol
+      const stream = await connection.newStream(protocol, {
+        runOnLimitedConnection: true
+      })
+
+      // close the write end immediately
+      const p = stream.closeWrite()
+
+      const remoteStream = await getRemoteStream.promise
+      // close the readable end of the remote stream
       await remoteStream.closeRead()
 
-      // send data from the remote to the local
+      // keep the remote write end open, this should delay the FIN_ACK reply to the local stream
       const remoteInputStream = pushable<Uint8Array>()
-      Promise.resolve().then(async () => {
-        for await (const buf of remoteInputStream) {
-          const sendMore = remoteStream.send(buf)
-
-          if (sendMore === false) {
-            await pEvent(remoteStream, 'drain', {
-              rejectionEvents: [
-                'close'
-              ]
-            })
-          }
-        }
+      void remoteStream.sink(remoteInputStream)
 
-        // close the remote writable end
-        await remoteStream.close()
+      // wait for remote to receive local close-write
+      await pRetry(() => {
+        if (remoteStream.readStatus !== 'closed') {
+          throw new Error('Remote stream read status ' + remoteStream.readStatus)
+        }
+      }, {
+        minTimeout: 100
       })
 
-      await Promise.all([
-        // wait for remote to receive local FIN
-        pEvent(remoteStream, 'remoteCloseWrite'),
-
-        // wait to receive FIN_ACK
-        localStream.close()
-      ])
-
-      // stop sending remote -> local
+      // remote closes write
       remoteInputStream.end()
 
+      // wait to receive FIN_ACK
+      await p
+
       // wait for remote to notice closure
       await pRetry(() => {
         if (remoteStream.status !== 'closed') {
@@ -459,12 +417,11 @@ export default (common: TestSetup<TransportTestFixtures>): void => {
         }
       })
 
-      // both ends should be closed
-      assertStreamClosed(localStream)
+      assertStreamClosed(stream)
       assertStreamClosed(remoteStream)
     })
 
-    it('can close local stream for writing while a remote stream is reading', async function () {
+    it('can close local stream for writing and reading while a remote stream is writing using source/sink', async function () {
       ({ dialer, listener, dialAddrs } = await getSetup(common))
 
       if (listener == null) {
@@ -473,80 +430,62 @@ export default (common: TestSetup<TransportTestFixtures>): void => {
 
       /**
        * NodeA             NodeB
-       * | DATA --->           |
        * | FIN --->            |
        * |            <--- FIN |
        * | FIN_ACK --->        |
        * |        <--- FIN_ACK |
        */
 
-      const getRemoteStream = Promise.withResolvers<Stream>()
+      const getRemoteStream = pDefer<Stream>()
       const protocol = '/close-local-while-remote-reads/1.0.0'
 
-      const streamHandler: StreamHandler = (stream) => {
-        getRemoteStream.resolve(stream)
+      const streamHandler: StreamHandler = ({ stream }) => {
+        void Promise.resolve().then(async () => {
+          getRemoteStream.resolve(stream)
+        })
       }
 
-      await listener.handle(protocol, streamHandler, {
+      await listener.handle(protocol, (info) => {
+        streamHandler(info)
+      }, {
         runOnLimitedConnection: true
       })
 
       const connection = await dialer.dial(dialAddrs[0])
 
-      const [
-        localStream,
-        remoteStream
-      ] = await Promise.all([
-        // open a stream on the echo protocol
-        connection.newStream(protocol, {
-          runOnLimitedConnection: true
-        }),
-        getRemoteStream.promise
-      ])
-
-      // ignore incoming data
-      void drain(remoteStream)
-
-      // close the remote stream writable end when the local sends a FIN
-      remoteStream.addEventListener('remoteCloseWrite', () => {
-        remoteStream.close()
-          .catch(err => {
-            remoteStream.abort(err)
-          })
+      // open a stream on the echo protocol
+      const stream = await connection.newStream(protocol, {
+        runOnLimitedConnection: true
       })
 
-      // send data to the remote then close the stream
-      const data = [
-        Uint8Array.from([0, 1, 2, 3]),
-        Uint8Array.from([4, 5, 6, 7]),
-        Uint8Array.from([8, 9, 0, 1])
-      ]
-
-      const [
-        remoteCloseEvent,
-        localCloseEvent
-      ] = await Promise.all([
-        // wait for the remote to close
-        pEvent(remoteStream, 'close'),
-        pEvent(localStream, 'close'),
-        (async () => {
-          for (const buf of data) {
-            if (!localStream.send(buf)) {
-              await pEvent(localStream, 'drain', {
-                rejectionEvents: [
-                  'close'
-                ]
-              })
-            }
-          }
+      // keep the remote write end open, this should delay the FIN_ACK reply to the local stream
+      const p = stream.sink([])
+
+      const remoteStream = await getRemoteStream.promise
+      // close the readable end of the remote stream
+      await remoteStream.closeRead()
+      // readable end should finish
+      await drain(remoteStream.source)
+
+      // wait for remote to receive local close-write
+      await pRetry(() => {
+        if (remoteStream.readStatus !== 'closed') {
+          throw new Error('Remote stream read status ' + remoteStream.readStatus)
+        }
+      }, {
+        minTimeout: 100
+      })
 
-          // close the local writable end
-          await localStream.close()
-        })()
-      ])
+      // remote closes write
+      await remoteStream.sink([])
 
-      expect(remoteCloseEvent).to.not.have.property('error', 'remote stream did not close cleanly')
-      expect(localCloseEvent).to.not.have.property('error', 'local stream did not close cleanly')
+      // wait to receive FIN_ACK
+      await p
+
+      // close read end of stream
+      await stream.closeRead()
+      // readable end should finish
+      await drain(stream.source)
 
       // wait for remote to notice closure
       await pRetry(() => {
@@ -555,50 +494,70 @@ export default (common: TestSetup<TransportTestFixtures>): void => {
         }
       })
 
-      // both ends should be closed
-      assertStreamClosed(localStream)
+      assertStreamClosed(stream)
       assertStreamClosed(remoteStream)
     })
+  })
 
-    it('can close a stream for writing but receive a large amount of data', async function () {
-      const timeout = 120_000
-      this.timeout(timeout);
-      ({ dialer, listener, dialAddrs } = await getSetup(common))
+  describe('events', () => {
+    let dialer: Libp2p<{ echo: Echo }>
+    let listener: Libp2p<{ echo: Echo }> | undefined
+    let listenMultiaddrMatcher: MultiaddrMatcher
+
+    afterEach(async () => {
+      await stop(dialer, listener)
+      await common.teardown()
+    })
+
+    it('emits listening', async function () {
+      ({ dialer, listener, listenMultiaddrMatcher } = await getSetup(common))
 
       if (listener == null) {
         return this.skip()
       }
 
-      const protocol = '/receive-data/1.0.0'
-      const chunkSize = 1024
-      const bytes = chunkSize * 1024 * 10
+      await listener.stop()
 
-      await listener.handle(protocol, async (stream) => {
-        for (let i = 0; i < bytes; i += chunkSize) {
-          const sendMore = stream.send(new Uint8Array(chunkSize))
-
-          if (!sendMore) {
-            await pEvent(stream, 'drain', {
-              rejectionEvents: [
-                'close'
-              ]
-            })
-          }
+      const transportListeningPromise = pDefer()
+
+      listener.addEventListener('transport:listening', (event) => {
+        const transportListener = event.detail
+
+        if (transportListener.getAddrs().some(ma => listenMultiaddrMatcher.exactMatch(ma))) {
+          transportListeningPromise.resolve()
         }
+      })
 
-        await stream.close()
+      await listener.start()
+
+      await raceSignal(transportListeningPromise.promise, AbortSignal.timeout(1000), {
+        errorMessage: 'Did not emit listening event'
       })
+    })
 
-      const stream = await dialer.dialProtocol(dialAddrs[0], protocol)
+    it('emits close', async function () {
+      ({ dialer, listener } = await getSetup(common))
+
+      if (listener == null) {
+        return this.skip()
+      }
 
-      const [
-        output
-      ] = await Promise.all([
-        all(stream),
-        stream.close()
-      ])
+      const transportManager = getTransportManager(listener)
+      const transportListener = transportManager.getListeners()
+        .filter(listener => listener.getAddrs().some(ma => listenMultiaddrMatcher.exactMatch(ma)))
+        .pop()
+
+      if (transportListener == null) {
+        throw new Error('Could not find address listener')
+      }
+
+      const p = pEvent(transportListener, 'close')
 
-      expect(new Uint8ArrayList(...output).byteLength).to.equal(bytes)
+      await listener.stop()
+
+      await raceSignal(p, AbortSignal.timeout(1000), {
+        errorMessage: 'Did not emit close event'
+      })
     })
   })
 }
@@ -609,4 +568,6 @@ function assertStreamClosed (stream: Stream): void {
   expect(stream.writeStatus).to.equal('closed')
 
   expect(stream.timeline.close).to.be.a('number')
+  expect(stream.timeline.closeRead).to.be.a('number')
+  expect(stream.timeline.closeWrite).to.be.a('number')
 }