@libp2p/interface-compliance-tests 6.1.8 → 6.1.9

package/src/transport/index.ts

@@ -1,27 +1,581 @@
-import dial from './dial-test.js'
-import filter from './filter-test.js'
-import listen from './listen-test.js'
+import { stop } from '@libp2p/interface'
+import { expect } from 'aegir/chai'
+import delay from 'delay'
+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 { isValidTick } from '../is-valid-tick.js'
+import { createPeer, getTransportManager, getUpgrader, slowNetwork } from './utils.js'
 import type { TestSetup } from '../index.js'
-import type { Transport } from '@libp2p/interface'
+import type { Echo } from '@libp2p/echo'
+import type { Connection, Libp2p, Stream, StreamHandler } from '@libp2p/interface'
 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 Connector {
-  delay(ms: number): void
-  restore(): void
+export interface TransportTestFixtures {
+  /**
+   * Addresses that will be used to dial listeners - both addresses must resolve
+   * to the same node
+   */
+  dialAddrs?: [Multiaddr, Multiaddr]
+
+  /**
+   * Filter out any addresses that cannot be dialed by the transport
+   */
+  dialMultiaddrMatcher: MultiaddrMatcher
+
+  /**
+   * Filter out any addresses that cannot be listened on by the transport
+   */
+  listenMultiaddrMatcher: MultiaddrMatcher
+
+  /**
+   * Config that creates a libp2p node that can dial a listener
+   */
+  dialer: Libp2pInit
+
+  /**
+   * Config that creates a libp2p node that can accept dials
+   */
+  listener?: Libp2pInit
 }
 
-export interface TransportTestFixtures {
-  listenAddrs: Multiaddr[]
-  dialAddrs: Multiaddr[]
-  dialer: Transport
-  listener: Transport
-  connector: Connector
+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(setup.dialer)
+  let listener
+
+  if (setup.listener != null) {
+    listener = await createPeer(setup.listener)
+  }
+
+  const dialAddrs = listener?.getMultiaddrs() ?? setup.dialAddrs
+
+  if (dialAddrs == null) {
+    throw new Error('Listener config or dial addresses must be specified')
+  }
+
+  return {
+    dialer,
+    listener,
+    dialAddrs: dialAddrs.filter(ma => setup.dialMultiaddrMatcher.exactMatch(ma)),
+    dialMultiaddrMatcher: setup.dialMultiaddrMatcher,
+    listenMultiaddrMatcher: setup.listenMultiaddrMatcher
+  }
 }
 
 export default (common: TestSetup<TransportTestFixtures>): void => {
   describe('interface-transport', () => {
-    dial(common)
-    listen(common)
-    filter(common)
+    let dialer: Libp2p<{ echo: Echo }>
+    let listener: Libp2p<{ echo: Echo }> | undefined
+    let dialAddrs: Multiaddr[]
+    let dialMultiaddrMatcher: MultiaddrMatcher
+
+    afterEach(async () => {
+      await stop(dialer, listener)
+      await common.teardown()
+    })
+
+    it('simple', async () => {
+      ({ dialer, listener, dialAddrs } = await getSetup(common))
+
+      const input = Uint8Array.from([0, 1, 2, 3, 4])
+      const output = await dialer.services.echo.echo(dialAddrs[0], input, {
+        signal: AbortSignal.timeout(5000)
+      })
+
+      expect(output).to.equalBytes(input)
+    })
+
+    it('should listen on multiple addresses', async () => {
+      ({ dialer, listener, dialAddrs } = await getSetup(common))
+
+      const input = Uint8Array.from([0, 1, 2, 3, 4])
+
+      await expect(dialer.services.echo.echo(dialAddrs[0], input, {
+        signal: AbortSignal.timeout(5000)
+      })).to.eventually.deep.equal(input)
+
+      await expect(dialer.services.echo.echo(dialAddrs[1], input, {
+        signal: AbortSignal.timeout(5000)
+      })).to.eventually.deep.equal(input)
+    })
+
+    it('can close connections', async () => {
+      ({ dialer, listener, dialAddrs } = await getSetup(common))
+
+      const conn = await dialer.dial(dialAddrs[0], {
+        signal: AbortSignal.timeout(5000)
+      })
+
+      await conn.close()
+      expect(isValidTick(conn.timeline.close)).to.equal(true)
+    })
+
+    it('abort before dialing throws AbortError', async () => {
+      ({ dialer, listener, dialAddrs } = await getSetup(common))
+
+      const controller = new AbortController()
+      controller.abort()
+
+      await expect(dialer.dial(dialAddrs[0], {
+        signal: controller.signal
+      })).to.eventually.be.rejected()
+        .with.property('name', 'AbortError')
+    })
+
+    it('abort while dialing throws AbortError', async () => {
+      ({ dialer, listener, dialAddrs } = await getSetup(common))
+      slowNetwork(dialer, 100)
+
+      const controller = new AbortController()
+      setTimeout(() => { controller.abort() }, 50)
+
+      await expect(dialer.dial(dialAddrs[0], {
+        signal: controller.signal
+      })).to.eventually.be.rejected()
+        .with.property('name', 'AbortError')
+    })
+
+    it('should close all streams when the connection closes', async () => {
+      ({ dialer, listener, dialAddrs } = await getSetup(common))
+
+      let incomingConnectionPromise: DeferredPromise<Connection> | undefined
+
+      if (listener != null) {
+        incomingConnectionPromise = pDefer<Connection>()
+
+        listener.addEventListener('connection:open', (event) => {
+          const conn = event.detail
+
+          if (conn.remotePeer.equals(dialer.peerId)) {
+            incomingConnectionPromise?.resolve(conn)
+          }
+        })
+      }
+
+      const connection = await dialer.dial(dialAddrs[0])
+      let remoteConn: Connection | undefined
+
+      if (incomingConnectionPromise != null) {
+        remoteConn = await incomingConnectionPromise.promise
+      }
+
+      for (let i = 0; i < 5; i++) {
+        await connection.newStream('/echo/1.0.0', {
+          maxOutboundStreams: 5
+        })
+      }
+
+      const streams = connection.streams
+
+      // Close the connection and verify all streams have been closed
+      await connection.close()
+
+      await pWaitFor(() => connection.streams.length === 0, {
+        timeout: 5000
+      })
+
+      if (remoteConn != null) {
+        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 () {
+      ({ dialer, listener, dialAddrs, dialMultiaddrMatcher } = await getSetup(common))
+
+      if (listener == null) {
+        return this.skip()
+      }
+
+      const upgrader = getUpgrader(listener)
+      upgrader.upgradeInbound = async () => {
+        await delay(100)
+        throw new Error('Oh noes!')
+      }
+
+      await expect(dialer.dial(dialAddrs[0])).to.eventually.be.rejected
+        .with.property('name', 'EncryptionFailedError')
+
+      expect(dialer.getConnections().filter(conn => {
+        return dialMultiaddrMatcher.exactMatch(conn.remoteAddr)
+      })).to.have.lengthOf(0)
+
+      if (listener != null) {
+        const remoteConnections = listener.getConnections(dialer.peerId)
+          .filter(conn => dialMultiaddrMatcher.exactMatch(conn.remoteAddr))
+        expect(remoteConnections).to.have.lengthOf(0)
+      }
+    })
+
+    it('should omit peerid in listening addresses', async function () {
+      ({ dialer, listener, dialAddrs } = await getSetup(common))
+
+      if (listener == null) {
+        return this.skip()
+      }
+
+      const tm = getTransportManager(listener)
+      const transportListeners = tm.getListeners()
+
+      for (const transportListener of transportListeners) {
+        for (const ma of transportListener.getAddrs()) {
+          expect(ma.toString()).to.not.include(`/p2p/${listener.peerId}`)
+        }
+      }
+    })
+
+    it('should handle one big write', async function () {
+      const timeout = 120_000
+      this.timeout(timeout);
+      ({ dialer, listener, dialAddrs } = await getSetup(common))
+
+      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).to.equalBytes(input)
+    })
+
+    it('should handle many small writes', async function () {
+      const timeout = 120_000
+      this.timeout(timeout);
+      ({ dialer, listener, dialAddrs } = await getSetup(common))
+
+      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)
+        })
+
+        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)
+          })
+      })
+
+      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('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))
+
+      if (listener == null) {
+        return this.skip()
+      }
+
+      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)
+          })
+      })
+
+      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 for writing and reading while a remote stream is writing', async function () {
+      ({ dialer, listener, dialAddrs } = await getSetup(common))
+
+      if (listener == null) {
+        return this.skip()
+      }
+
+      /**
+       * NodeA             NodeB
+       * |   <--- STOP_SENDING |
+       * | FIN --->            |
+       * |            <--- FIN |
+       * | FIN_ACK --->        |
+       * |        <--- FIN_ACK |
+       */
+
+      const getRemoteStream = pDefer<Stream>()
+      const protocol = '/close-local-while-remote-writes/1.0.0'
+
+      const streamHandler: StreamHandler = ({ stream }) => {
+        void Promise.resolve().then(async () => {
+          getRemoteStream.resolve(stream)
+        })
+      }
+
+      await listener.handle(protocol, (info) => {
+        streamHandler(info)
+      }, {
+        runOnLimitedConnection: true
+      })
+
+      const connection = await dialer.dial(dialAddrs[0])
+
+      // 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()
+
+      // keep the remote write end open, this should delay the FIN_ACK reply to the local stream
+      const remoteInputStream = pushable<Uint8Array>()
+      void remoteStream.sink(remoteInputStream)
+
+      // 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
+      })
+
+      // remote closes write
+      remoteInputStream.end()
+
+      // wait to receive FIN_ACK
+      await p
+
+      // wait for remote to notice closure
+      await pRetry(() => {
+        if (remoteStream.status !== 'closed') {
+          throw new Error('Remote stream not closed')
+        }
+      })
+
+      assertStreamClosed(stream)
+      assertStreamClosed(remoteStream)
+    })
+
+    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) {
+        return this.skip()
+      }
+
+      /**
+       * NodeA             NodeB
+       * | FIN --->            |
+       * |            <--- FIN |
+       * | FIN_ACK --->        |
+       * |        <--- FIN_ACK |
+       */
+
+      const getRemoteStream = pDefer<Stream>()
+      const protocol = '/close-local-while-remote-reads/1.0.0'
+
+      const streamHandler: StreamHandler = ({ stream }) => {
+        void Promise.resolve().then(async () => {
+          getRemoteStream.resolve(stream)
+        })
+      }
+
+      await listener.handle(protocol, (info) => {
+        streamHandler(info)
+      }, {
+        runOnLimitedConnection: true
+      })
+
+      const connection = await dialer.dial(dialAddrs[0])
+
+      // open a stream on the echo protocol
+      const stream = await connection.newStream(protocol, {
+        runOnLimitedConnection: true
+      })
+
+      // 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
+      })
+
+      // remote closes write
+      await remoteStream.sink([])
+
+      // 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(() => {
+        if (remoteStream.status !== 'closed') {
+          throw new Error('Remote stream not closed')
+        }
+      })
+
+      assertStreamClosed(stream)
+      assertStreamClosed(remoteStream)
+    })
+  })
+
+  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()
+      }
+
+      await listener.stop()
+
+      const transportListeningPromise = pDefer()
+
+      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), {
+        errorMessage: '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), {
+        errorMessage: 'Did not emit close event'
+      })
+    })
   })
 }
+
+function assertStreamClosed (stream: Stream): void {
+  expect(stream.status).to.equal('closed')
+  expect(stream.readStatus).to.equal('closed')
+  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')
+}

package/src/transport/utils.ts

@@ -0,0 +1,76 @@
+/* eslint-env mocha */
+
+import { echo } from '@libp2p/echo'
+import { memory } from '@libp2p/memory'
+import { plaintext } from '@libp2p/plaintext'
+import delay from 'delay'
+import map from 'it-map'
+import { createLibp2p } from 'libp2p'
+import { mockMuxer } from '../mocks/muxer.js'
+import type { Echo } from '@libp2p/echo'
+import type { Libp2p, Upgrader } from '@libp2p/interface'
+import type { TransportManager } from '@libp2p/interface-internal'
+import type { Libp2pOptions } from 'libp2p'
+
+export async function createPeer (config: Partial<Libp2pOptions> = {}): Promise<Libp2p<{ echo: Echo }>> {
+  return createLibp2p({
+    transports: [
+      memory()
+    ],
+    connectionEncrypters: [
+      plaintext()
+    ],
+    streamMuxers: [
+      () => mockMuxer()
+    ],
+    connectionGater: {
+      denyDialMultiaddr: () => false
+    },
+    ...config,
+    services: {
+      ...config.services,
+      echo: echo({
+        maxInboundStreams: 5
+      })
+    }
+  })
+}
+
+/**
+ * Monkey patch the upgrader in the passed libp2p to add latency to any
+ * multiaddr connections upgraded to connections - this is to work with
+ * transports that have their own muxers/encrypters and do not support
+ * connection protection
+ */
+export function slowNetwork (libp2p: any, latency: number): void {
+  const upgrader: Upgrader = getUpgrader(libp2p)
+
+  const originalUpgradeInbound = upgrader.upgradeInbound.bind(upgrader)
+  const originalUpgradeOutbound = upgrader.upgradeOutbound.bind(upgrader)
+
+  upgrader.upgradeInbound = async (maConn, opts) => {
+    maConn.source = map(maConn.source, async (buf) => {
+      await delay(latency)
+      return buf
+    })
+
+    return originalUpgradeInbound(maConn, opts)
+  }
+
+  upgrader.upgradeOutbound = async (maConn, opts) => {
+    maConn.source = map(maConn.source, async (buf) => {
+      await delay(latency)
+      return buf
+    })
+
+    return originalUpgradeOutbound(maConn, opts)
+  }
+}
+
+export function getUpgrader (libp2p: any): Upgrader {
+  return libp2p.components.upgrader
+}
+
+export function getTransportManager (libp2p: any): TransportManager {
+  return libp2p.components.transportManager
+}

package/dist/src/connection/index.d.ts

@@ -1,5 +0,0 @@
-import type { TestSetup } from '../index.js';
-import type { Connection } from '@libp2p/interface';
-declare const _default: (test: TestSetup<Connection>) => void;
-export default _default;
-//# sourceMappingURL=index.d.ts.map

package/dist/src/connection/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/connection/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;+BAE7B,UAAU,UAAU,CAAC,KAAG,IAAI;AAAlD,wBAgKC"}