@libp2p/interface-compliance-tests 6.1.8-665769021 → 6.1.8-7626b224d

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/interface-compliance-tests",
-  "version": "6.1.8-665769021",
+  "version": "6.1.8-7626b224d",
   "description": "Compliance tests for JS libp2p interfaces",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/interface-compliance-tests#readme",
@@ -48,10 +48,6 @@
       "types": "./dist/src/index.d.ts",
       "import": "./dist/src/index.js"
     },
-    "./connection": {
-      "types": "./dist/src/connection/index.d.ts",
-      "import": "./dist/src/connection/index.js"
-    },
     "./connection-encryption": {
       "types": "./dist/src/connection-encryption/index.d.ts",
       "import": "./dist/src/connection-encryption/index.js"
@@ -108,15 +104,19 @@
     "test:electron-main": "aegir test -t electron-main"
   },
   "dependencies": {
-    "@libp2p/crypto": "5.0.6-665769021",
-    "@libp2p/interface": "2.2.0-665769021",
-    "@libp2p/interface-internal": "2.0.10-665769021",
-    "@libp2p/logger": "5.1.3-665769021",
-    "@libp2p/multistream-select": "6.0.8-665769021",
-    "@libp2p/peer-collections": "6.0.10-665769021",
-    "@libp2p/peer-id": "5.0.7-665769021",
-    "@libp2p/utils": "6.1.3-665769021",
+    "@libp2p/crypto": "5.0.6-7626b224d",
+    "@libp2p/echo": "2.1.1-7626b224d",
+    "@libp2p/interface": "2.2.0-7626b224d",
+    "@libp2p/interface-internal": "2.0.10-7626b224d",
+    "@libp2p/logger": "5.1.3-7626b224d",
+    "@libp2p/memory": "0.0.0-7626b224d",
+    "@libp2p/multistream-select": "6.0.8-7626b224d",
+    "@libp2p/peer-collections": "6.0.10-7626b224d",
+    "@libp2p/peer-id": "5.0.7-7626b224d",
+    "@libp2p/plaintext": "2.0.10-7626b224d",
+    "@libp2p/utils": "6.1.3-7626b224d",
     "@multiformats/multiaddr": "^12.2.3",
+    "@multiformats/multiaddr-matcher": "^1.5.0",
     "abortable-iterator": "^5.0.1",
     "aegir": "^44.0.1",
     "delay": "^6.0.0",
@@ -131,12 +131,14 @@
     "it-pushable": "^3.2.3",
     "it-stream-types": "^2.0.1",
     "it-to-buffer": "^4.0.7",
+    "libp2p": "2.2.1-7626b224d",
     "merge-options": "^3.0.4",
     "p-defer": "^4.0.1",
     "p-event": "^6.0.1",
     "p-limit": "^6.0.0",
     "p-wait-for": "^5.0.2",
     "protons-runtime": "^5.4.0",
+    "race-signal": "^1.1.0",
     "sinon": "^18.0.0",
     "tdigest": "^0.1.2",
     "uint8arraylist": "^2.4.8",

package/src/matchers.ts

@@ -2,10 +2,16 @@ import Sinon from 'sinon'
 import type { PeerId } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
+/**
+ * @deprecated PeerIds can be passed to sinon matchers directly
+ */
 export function matchPeerId (peerId: PeerId): Sinon.SinonMatcher {
   return Sinon.match(p => p.toString() === peerId.toString())
 }
 
+/**
+ * @deprecated Multiaddrs can be passed to sinon matchers directly
+ */
 export function matchMultiaddr (ma: Multiaddr): Sinon.SinonMatcher {
   return Sinon.match(m => m.toString() === ma.toString())
 }

package/src/mocks/muxer.ts

@@ -27,9 +27,15 @@ interface ResetMessage {
   direction: Direction
 }
 
-interface CloseMessage {
+interface CloseWriteMessage {
   id: string
-  type: 'close'
+  type: 'closeWrite'
+  direction: Direction
+}
+
+interface CloseReadMessage {
+  id: string
+  type: 'closeRead'
   direction: Direction
 }
 
@@ -39,7 +45,7 @@ interface CreateMessage {
   direction: 'outbound'
 }
 
-type StreamMessage = DataMessage | ResetMessage | CloseMessage | CreateMessage
+type StreamMessage = DataMessage | ResetMessage | CloseWriteMessage | CloseReadMessage | CreateMessage
 
 export interface MockMuxedStreamInit extends AbstractStreamInit {
   push: Pushable<StreamMessage>
@@ -84,16 +90,21 @@ class MuxedStream extends AbstractStream {
   }
 
   sendCloseWrite (): void {
-    const closeMsg: CloseMessage = {
+    const closeMsg: CloseWriteMessage = {
       id: this.id,
-      type: 'close',
+      type: 'closeWrite',
       direction: this.direction
     }
     this.push.push(closeMsg)
   }
 
   sendCloseRead (): void {
-    // does not support close read, only close write
+    const closeMsg: CloseReadMessage = {
+      id: this.id,
+      type: 'closeRead',
+      direction: this.direction
+    }
+    this.push.push(closeMsg)
   }
 }
 
@@ -153,10 +164,10 @@ class MockMuxer implements StreamMuxer {
         }
       )
 
-      this.log('muxed stream ended')
+      this.log('muxer ended')
       this.input.end()
     } catch (err: any) {
-      this.log('muxed stream errored', err)
+      this.log.error('muxer errored - %e', err)
       this.input.end(err)
     }
   }
@@ -192,9 +203,12 @@ class MockMuxer implements StreamMuxer {
     } else if (message.type === 'reset') {
       this.log('-> reset stream %s %s', muxedStream.direction, muxedStream.id)
       muxedStream.reset()
-    } else if (message.type === 'close') {
-      this.log('-> closing stream %s %s', muxedStream.direction, muxedStream.id)
+    } else if (message.type === 'closeWrite') {
+      this.log('-> closing writeable end of stream %s %s', muxedStream.direction, muxedStream.id)
       muxedStream.remoteCloseWrite()
+    } else if (message.type === 'closeRead') {
+      this.log('-> closing readable end of stream %s %s', muxedStream.direction, muxedStream.id)
+      muxedStream.remoteCloseRead()
     }
   }
 

package/src/mocks/upgrader.ts

@@ -28,7 +28,7 @@ class MockUpgrader implements Upgrader {
     return connection
   }
 
-  async upgradeInbound (multiaddrConnection: MultiaddrConnection, opts: UpgraderOptions = {}): Promise<Connection> {
+  async upgradeInbound (multiaddrConnection: MultiaddrConnection, opts: UpgraderOptions = {}): Promise<void> {
     const connection = mockConnection(multiaddrConnection, {
       direction: 'inbound',
       registrar: this.registrar,
@@ -36,8 +36,6 @@ class MockUpgrader implements Upgrader {
     })
 
     this.events?.safeDispatchEvent('connection:open', { detail: connection })
-
-    return connection
   }
 }
 

package/src/transport/index.ts

@@ -1,27 +1,325 @@
-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 pDefer from 'p-defer'
+import { pEvent } from 'p-event'
+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 } 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
+      }
+
+      const streams: Stream[] = []
+
+      for (let i = 0; i < 5; i++) {
+        streams.push(await connection.newStream('/echo/1.0.0', {
+          maxOutboundStreams: 5
+        }))
+      }
+
+      // 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)
+      }
+    })
+  })
+
+  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'
+      })
+    })
   })
 }

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"}