@libp2p/interface-compliance-tests 6.1.7 → 6.1.8-32ca76fcb

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/interface-compliance-tests",
-  "version": "6.1.7",
+  "version": "6.1.8-32ca76fcb",
   "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,14 +104,17 @@
     "test:electron-main": "aegir test -t electron-main"
   },
   "dependencies": {
-    "@libp2p/crypto": "^5.0.5",
-    "@libp2p/interface": "^2.1.3",
-    "@libp2p/interface-internal": "^2.0.9",
-    "@libp2p/logger": "^5.1.2",
-    "@libp2p/multistream-select": "^6.0.7",
-    "@libp2p/peer-collections": "^6.0.9",
-    "@libp2p/peer-id": "^5.0.6",
-    "@libp2p/utils": "^6.1.2",
+    "@libp2p/crypto": "5.0.6-32ca76fcb",
+    "@libp2p/echo": "2.1.1-32ca76fcb",
+    "@libp2p/interface": "2.2.0-32ca76fcb",
+    "@libp2p/interface-internal": "2.0.10-32ca76fcb",
+    "@libp2p/logger": "5.1.3-32ca76fcb",
+    "@libp2p/memory": "0.0.0-32ca76fcb",
+    "@libp2p/multistream-select": "6.0.8-32ca76fcb",
+    "@libp2p/peer-collections": "6.0.10-32ca76fcb",
+    "@libp2p/peer-id": "5.0.7-32ca76fcb",
+    "@libp2p/plaintext": "2.0.10-32ca76fcb",
+    "@libp2p/utils": "6.1.3-32ca76fcb",
     "@multiformats/multiaddr": "^12.2.3",
     "abortable-iterator": "^5.0.1",
     "aegir": "^44.0.1",
@@ -131,12 +130,14 @@
     "it-pushable": "^3.2.3",
     "it-stream-types": "^2.0.1",
     "it-to-buffer": "^4.0.7",
+    "libp2p": "2.2.1-32ca76fcb",
     "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/transport/index.ts

@@ -1,27 +1,415 @@
-import dial from './dial-test.js'
-import filter from './filter-test.js'
-import listen from './listen-test.js'
+import { echo } from '@libp2p/echo'
+import { stop } from '@libp2p/interface'
+import { expect } from 'aegir/chai'
+import delay from 'delay'
+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, Transport } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
-export interface Connector {
-  delay(ms: number): void
-  restore(): void
-}
-
 export interface TransportTestFixtures {
-  listenAddrs: Multiaddr[]
-  dialAddrs: Multiaddr[]
-  dialer: Transport
-  listener: Transport
-  connector: Connector
+  /**
+   * Addresses that will be used to dial listeners from `listenAddrs`
+   */
+  dialAddrs: [Multiaddr, Multiaddr]
+
+  /**
+   * Addresses that will be used to create listeners to dial
+   */
+  listenAddrs?: [Multiaddr, Multiaddr]
+
+  /**
+   * Only run the dial portion of the tests, do not try to create listeners
+   */
+  dialOnly?: boolean
+
+  transport(components: any): Transport
 }
 
 export default (common: TestSetup<TransportTestFixtures>): void => {
   describe('interface-transport', () => {
-    dial(common)
-    listen(common)
-    filter(common)
+    let dialAddrs: Multiaddr[]
+    let listenAddrs: Multiaddr[]
+    let transport: (components: any) => Transport
+    let dialer: Libp2p<{ echo: Echo }>
+    let listener: Libp2p<{ echo: Echo }> | undefined
+    let dialOnly: boolean
+
+    beforeEach(async () => {
+      ({ dialAddrs, listenAddrs = dialAddrs, transport, dialOnly = false } = await common.setup())
+    })
+
+    afterEach(async () => {
+      await stop(dialer, listener)
+      await common.teardown()
+    })
+
+    it('simple', async () => {
+      dialer = await createPeer({
+        transports: [
+          transport
+        ]
+      })
+
+      if (!dialOnly) {
+        listener = await createPeer({
+          addresses: {
+            listen: [listenAddrs[0].toString()]
+          },
+          transports: [
+            transport
+          ]
+        })
+      }
+
+      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 = await createPeer({
+        transports: [
+          transport
+        ]
+      })
+
+      if (!dialOnly) {
+        listener = await createPeer({
+          addresses: {
+            listen: [
+              listenAddrs[0].toString(),
+              listenAddrs[1].toString()
+            ]
+          },
+          transports: [
+            transport
+          ]
+        })
+      }
+
+      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 = await createPeer({
+        transports: [
+          transport
+        ]
+      })
+
+      if (!dialOnly) {
+        listener = await createPeer({
+          addresses: {
+            listen: [listenAddrs[0].toString()]
+          },
+          transports: [
+            transport
+          ]
+        })
+      }
+
+      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 = await createPeer({
+        transports: [
+          transport
+        ]
+      })
+
+      if (!dialOnly) {
+        listener = await createPeer({
+          addresses: {
+            listen: [listenAddrs[0].toString()]
+          },
+          transports: [
+            transport
+          ]
+        })
+      }
+
+      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 = await createPeer({
+        transports: [
+          transport
+        ]
+      })
+
+      if (!dialOnly) {
+        listener = await createPeer({
+          addresses: {
+            listen: [listenAddrs[0].toString()]
+          },
+          transports: [
+            transport
+          ]
+        })
+      }
+      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 = await createPeer({
+        transports: [
+          transport
+        ]
+      })
+
+      if (!dialOnly) {
+        listener = await createPeer({
+          addresses: {
+            listen: [listenAddrs[0].toString()]
+          },
+          transports: [
+            transport
+          ],
+          services: {
+            echo: echo({
+              maxInboundStreams: 5
+            })
+          }
+        })
+      }
+
+      const connection = await dialer.dial(listenAddrs[0])
+      let remoteConn: Connection | undefined
+
+      if (listener != null) {
+        const remoteConnections = listener.getConnections(dialer.peerId)
+        expect(remoteConnections).to.have.lengthOf(1)
+        remoteConn = remoteConnections[0]
+      }
+
+      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)
+
+      if (remoteConn != null) {
+        await pWaitFor(() => remoteConn.streams.length === 0)
+      }
+
+      expect(streams.find(stream => stream.status !== 'closed')).to.be.undefined()
+    })
+
+    it('should not handle connection if upgradeInbound rejects', async function () {
+      if (dialOnly) {
+        return this.skip()
+      }
+
+      dialer = await createPeer({
+        transports: [
+          transport
+        ]
+      })
+
+      if (!dialOnly) {
+        listener = await createPeer({
+          addresses: {
+            listen: [listenAddrs[0].toString()]
+          },
+          transports: [
+            transport
+          ]
+        })
+      }
+
+      const upgrader = getUpgrader(listener)
+      upgrader.upgradeInbound = async () => {
+        await delay(100)
+        throw new Error('Oh noes!')
+      }
+
+      await expect(dialer.dial(listenAddrs[0])).to.eventually.be.rejected
+        .with.property('name', 'EncryptionFailedError')
+
+      expect(dialer.getConnections()).to.have.lengthOf(0)
+
+      if (listener != null) {
+        expect(listener.getConnections()).to.have.lengthOf(0)
+      }
+    })
+  })
+
+  describe('events', () => {
+    let listenAddrs: Multiaddr[]
+    let dialAddrs: Multiaddr[]
+    let transport: (components: any) => Transport
+    let dialer: Libp2p<{ echo: Echo }>
+    let listener: Libp2p<{ echo: Echo }> | undefined
+    let dialOnly: boolean
+
+    beforeEach(async () => {
+      ({ dialAddrs, listenAddrs = dialAddrs, transport, dialOnly = false } = await common.setup())
+    })
+
+    afterEach(async () => {
+      await stop(dialer, listener)
+      await common.teardown()
+    })
+
+    it('emits connection', async function () {
+      if (dialOnly) {
+        return this.skip()
+      }
+
+      dialer = await createPeer({
+        transports: [
+          transport
+        ]
+      })
+
+      if (!dialOnly) {
+        listener = await createPeer({
+          addresses: {
+            listen: [listenAddrs[0].toString()]
+          },
+          transports: [
+            transport
+          ]
+        })
+      }
+
+      const transportManager = getTransportManager(listener)
+      const transportListener = transportManager.getListeners()[0]
+
+      const p = pEvent(transportListener, 'connection')
+
+      await expect(dialer.dial(dialAddrs[0])).to.eventually.be.ok()
+
+      await raceSignal(p, AbortSignal.timeout(1000), {
+        errorMessage: 'Did not emit connection event'
+      })
+    })
+
+    it('emits listening', async function () {
+      if (dialOnly) {
+        return this.skip()
+      }
+
+      dialer = await createPeer({
+        transports: [
+          transport
+        ]
+      })
+
+      if (!dialOnly) {
+        listener = await createPeer({
+          addresses: {
+            listen: [listenAddrs[0].toString()]
+          },
+          transports: [
+            transport
+          ]
+        })
+      }
+
+      const transportManager = getTransportManager(listener)
+      const t = transportManager.dialTransportForMultiaddr(dialAddrs[0])
+
+      if (t == null) {
+        throw new Error(`No transport configured for dial address ${dialAddrs[0]}`)
+      }
+
+      let p: Promise<unknown> | undefined
+      const originalCreateListener = t.createListener.bind(t)
+
+      t.createListener = (opts) => {
+        const listener = originalCreateListener(opts)
+        p = pEvent(listener, 'listening')
+
+        return listener
+      }
+
+      await transportManager.listen([
+        listenAddrs[1]
+      ])
+
+      if (p == null) {
+        throw new Error('Listener was not created')
+      }
+
+      await raceSignal(p, AbortSignal.timeout(1000), {
+        errorMessage: 'Did not emit connection event'
+      })
+    })
+
+    it('emits close', async function () {
+      if (dialOnly) {
+        return this.skip()
+      }
+
+      dialer = await createPeer({
+        transports: [
+          transport
+        ]
+      })
+      listener = await createPeer({
+        addresses: {
+          listen: [listenAddrs[0].toString()]
+        },
+        transports: [
+          transport
+        ]
+      })
+
+      const transportManager = getTransportManager(listener)
+      const transportListener = transportManager.getListeners()[0]
+
+      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<{ echo: Echo }>> = {}): Promise<Libp2p<{ echo: Echo }>> {
+  const node = await createLibp2p({
+    transports: [
+      memory()
+    ],
+    connectionEncrypters: [
+      plaintext()
+    ],
+    streamMuxers: [
+      () => mockMuxer()
+    ],
+    connectionGater: {
+      denyDialMultiaddr: () => false
+    },
+    ...config,
+    services: {
+      echo: echo(),
+      ...config.services
+    }
+  })
+
+  return node
+}
+
+/**
+ * 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"}