@libp2p/interface-compliance-tests 3.0.7 → 4.0.0-5ffa7a74

package/src/connection/index.ts

@@ -0,0 +1,182 @@
+import { expect } from 'aegir/chai'
+import sinon from 'sinon'
+import { stubInterface } from 'ts-sinon'
+import type { TestSetup } from '../index.js'
+import type { Connection, Stream } from '@libp2p/interface/connection'
+
+export default (test: TestSetup<Connection>): void => {
+  describe('connection', () => {
+    describe('open connection', () => {
+      let connection: Connection
+
+      beforeEach(async () => {
+        connection = await test.setup()
+      })
+
+      afterEach(async () => {
+        await connection.close()
+        await test.teardown()
+      })
+
+      it('should have properties set', () => {
+        expect(connection.id).to.exist()
+        expect(connection.remotePeer).to.exist()
+        expect(connection.remoteAddr).to.exist()
+        expect(connection.status).to.equal('open')
+        expect(connection.timeline.open).to.exist()
+        expect(connection.timeline.close).to.not.exist()
+        expect(connection.direction).to.exist()
+        expect(connection.streams).to.eql([])
+        expect(connection.tags).to.eql([])
+      })
+
+      it('should get the metadata of an open connection', () => {
+        expect(connection.status).to.equal('open')
+        expect(connection.direction).to.exist()
+        expect(connection.timeline.open).to.exist()
+        expect(connection.timeline.close).to.not.exist()
+      })
+
+      it('should return an empty array of streams', () => {
+        const streams = connection.streams
+
+        expect(streams).to.eql([])
+      })
+
+      it('should be able to create a new stream', async () => {
+        expect(connection.streams).to.be.empty()
+
+        const protocolToUse = '/echo/0.0.1'
+        const stream = await connection.newStream([protocolToUse])
+
+        expect(stream).to.have.property('protocol', protocolToUse)
+
+        const connStreams = connection.streams
+
+        expect(stream).to.exist()
+        expect(connStreams).to.exist()
+        expect(connStreams).to.have.lengthOf(1)
+        expect(connStreams[0]).to.equal(stream)
+      })
+    })
+
+    describe('close connection', () => {
+      let connection: Connection
+      let timelineProxy
+      const proxyHandler = {
+        set () {
+          // @ts-expect-error - TS fails to infer here
+          return Reflect.set(...arguments)
+        }
+      }
+
+      beforeEach(async () => {
+        timelineProxy = new Proxy({
+          open: Date.now() - 10,
+          upgraded: Date.now()
+        }, proxyHandler)
+
+        connection = await test.setup()
+        connection.timeline = timelineProxy
+      })
+
+      afterEach(async () => {
+        await test.teardown()
+      })
+
+      it('should be able to close the connection after being created', async () => {
+        expect(connection.timeline.close).to.not.exist()
+        await connection.close()
+
+        expect(connection.timeline.close).to.exist()
+        expect(connection.status).to.equal('closed')
+      })
+
+      it('should be able to close the connection after opening a stream', async () => {
+        // Open stream
+        const protocol = '/echo/0.0.1'
+        await connection.newStream([protocol])
+
+        // Close connection
+        expect(connection.timeline.close).to.not.exist()
+        await connection.close()
+
+        expect(connection.timeline.close).to.exist()
+        expect(connection.status).to.equal('closed')
+      })
+
+      it('should properly track streams', async () => {
+        // Open stream
+        const protocol = '/echo/0.0.1'
+        const stream = await connection.newStream([protocol])
+        expect(stream).to.have.property('protocol', protocol)
+
+        // Close stream
+        await stream.close()
+
+        expect(connection.streams.filter(s => s.id === stream.id)).to.be.empty()
+      })
+
+      it('should track outbound streams', async () => {
+        // Open stream
+        const protocol = '/echo/0.0.1'
+        const stream = await connection.newStream(protocol)
+        expect(stream).to.have.property('direction', 'outbound')
+      })
+
+      it.skip('should track inbound streams', async () => {
+        // Add an remotely opened stream
+        const stream = stubInterface<Stream>()
+        connection.addStream(stream)
+        expect(stream).to.have.property('direction', 'inbound')
+      })
+
+      it('should support a proxy on the timeline', async () => {
+        sinon.spy(proxyHandler, 'set')
+        expect(connection.timeline.close).to.not.exist()
+
+        await connection.close()
+        // @ts-expect-error - fails to infer callCount
+        expect(proxyHandler.set.callCount).to.equal(1)
+        // @ts-expect-error - fails to infer getCall
+        const [obj, key, value] = proxyHandler.set.getCall(0).args
+        expect(obj).to.eql(connection.timeline)
+        expect(key).to.equal('close')
+        expect(value).to.be.a('number').that.equals(connection.timeline.close)
+      })
+
+      it('should fail to create a new stream if the connection is closing', async () => {
+        expect(connection.timeline.close).to.not.exist()
+        const p = connection.close()
+
+        try {
+          const protocol = '/echo/0.0.1'
+          await connection.newStream([protocol])
+        } catch (err: any) {
+          expect(err).to.exist()
+          return
+        } finally {
+          await p
+        }
+
+        throw new Error('should fail to create a new stream if the connection is closing')
+      })
+
+      it('should fail to create a new stream if the connection is closed', async () => {
+        expect(connection.timeline.close).to.not.exist()
+        await connection.close()
+
+        try {
+          const protocol = '/echo/0.0.1'
+          await connection.newStream([protocol])
+        } catch (err: any) {
+          expect(err).to.exist()
+          expect(err.code).to.equal('ERR_CONNECTION_CLOSED')
+          return
+        }
+
+        throw new Error('should fail to create a new stream if the connection is closing')
+      })
+    })
+  })
+}

package/src/connection-encryption/index.ts

@@ -0,0 +1,97 @@
+import { UnexpectedPeerError } from '@libp2p/interface/errors'
+import * as PeerIdFactory from '@libp2p/peer-id-factory'
+import { expect } from 'aegir/chai'
+import all from 'it-all'
+import { pipe } from 'it-pipe'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import peers from '../peers.js'
+import { createMaConnPair } from './utils/index.js'
+import type { TestSetup } from '../index.js'
+import type { ConnectionEncrypter } from '@libp2p/interface/connection-encrypter'
+import type { PeerId } from '@libp2p/interface/peer-id'
+
+export default (common: TestSetup<ConnectionEncrypter>): void => {
+  describe('interface-connection-encrypter compliance tests', () => {
+    let crypto: ConnectionEncrypter
+    let localPeer: PeerId
+    let remotePeer: PeerId
+    let mitmPeer: PeerId
+
+    before(async () => {
+      [
+        crypto,
+        localPeer,
+        remotePeer,
+        mitmPeer
+      ] = await Promise.all([
+        common.setup(),
+        PeerIdFactory.createFromJSON(peers[0]),
+        PeerIdFactory.createFromJSON(peers[1]),
+        PeerIdFactory.createFromJSON(peers[2])
+      ])
+    })
+
+    after(async () => {
+      await common.teardown()
+    })
+
+    it('has a protocol string', () => {
+      expect(crypto.protocol).to.exist()
+      expect(crypto.protocol).to.be.a('string')
+    })
+
+    it('it wraps the provided duplex connection', async () => {
+      const [localConn, remoteConn] = createMaConnPair()
+
+      const [
+        inboundResult,
+        outboundResult
+      ] = await Promise.all([
+        crypto.secureInbound(remotePeer, localConn),
+        crypto.secureOutbound(localPeer, remoteConn, remotePeer)
+      ])
+
+      // Echo server
+      void pipe(inboundResult.conn, inboundResult.conn)
+
+      // Send some data and collect the result
+      const input = uint8ArrayFromString('data to encrypt')
+      const result = await pipe(
+        [input],
+        outboundResult.conn,
+        async (source) => all(source)
+      )
+
+      expect(result).to.eql([input])
+    })
+
+    it('should return the remote peer id', async () => {
+      const [localConn, remoteConn] = createMaConnPair()
+
+      const [
+        inboundResult,
+        outboundResult
+      ] = await Promise.all([
+        crypto.secureInbound(remotePeer, localConn),
+        crypto.secureOutbound(localPeer, remoteConn, remotePeer)
+      ])
+
+      // Inbound should return the initiator (local) peer
+      expect(inboundResult.remotePeer.toBytes()).to.equalBytes(localPeer.toBytes())
+      // Outbound should return the receiver (remote) peer
+      expect(outboundResult.remotePeer.toBytes()).to.equalBytes(remotePeer.toBytes())
+    })
+
+    it('inbound connections should verify peer integrity if known', async () => {
+      const [localConn, remoteConn] = createMaConnPair()
+
+      await Promise.all([
+        crypto.secureInbound(remotePeer, localConn, mitmPeer),
+        crypto.secureOutbound(localPeer, remoteConn, remotePeer)
+      ]).then(() => expect.fail(), (err) => {
+        expect(err).to.exist()
+        expect(err).to.have.property('code', UnexpectedPeerError.code)
+      })
+    })
+  })
+}

package/src/connection-encryption/utils/index.ts

@@ -0,0 +1,24 @@
+import { multiaddr } from '@multiformats/multiaddr'
+import { duplexPair } from 'it-pair/duplex'
+import type { MultiaddrConnection } from '@libp2p/interface/connection'
+import type { Duplex, Source } from 'it-stream-types'
+
+export function createMaConnPair (): [MultiaddrConnection, MultiaddrConnection] {
+  const [local, remote] = duplexPair<Uint8Array>()
+
+  function duplexToMaConn (duplex: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>): MultiaddrConnection {
+    const output: MultiaddrConnection = {
+      ...duplex,
+      close: async () => {},
+      abort: () => {},
+      remoteAddr: multiaddr('/ip4/127.0.0.1/tcp/4001'),
+      timeline: {
+        open: Date.now()
+      }
+    }
+
+    return output
+  }
+
+  return [duplexToMaConn(local), duplexToMaConn(remote)]
+}

package/src/index.ts

@@ -1,4 +1,3 @@
-
 export interface TestSetup<T, SetupArgs = Record<string, unknown>> {
   setup: (args?: SetupArgs) => Promise<T>
   teardown: () => Promise<void>

package/src/is-valid-tick.ts

@@ -1,4 +1,3 @@
-
 /**
  * A tick is considered valid if it happened between now
  * and `ms` milliseconds ago

package/src/mocks/connection-encrypter.ts

@@ -0,0 +1,113 @@
+import { UnexpectedPeerError } from '@libp2p/interface/errors'
+import { peerIdFromBytes } from '@libp2p/peer-id'
+import { multiaddr } from '@multiformats/multiaddr'
+import { handshake } from 'it-handshake'
+import map from 'it-map'
+import { duplexPair } from 'it-pair/duplex'
+import { pipe } from 'it-pipe'
+import type { ConnectionEncrypter } from '@libp2p/interface/connection-encrypter'
+import type { Transform, Source } from 'it-stream-types'
+
+// A basic transform that does nothing to the data
+const transform = <T>(): Transform<Source<T>, AsyncGenerator<T>> => {
+  return (source: Source<T>) => (async function * () {
+    for await (const chunk of source) {
+      yield chunk
+    }
+  })()
+}
+
+export function mockConnectionEncrypter (): ConnectionEncrypter {
+  const encrypter: ConnectionEncrypter = {
+    protocol: 'insecure',
+    secureInbound: async (localPeer, duplex, expectedPeer) => {
+      // 1. Perform a basic handshake.
+      const shake = handshake<Uint8Array>(duplex)
+      shake.write(localPeer.toBytes())
+      const remoteId = await shake.read()
+
+      if (remoteId == null) {
+        throw new Error('Could not read remote ID')
+      }
+
+      const remotePeer = peerIdFromBytes(remoteId.slice())
+      shake.rest()
+
+      if (expectedPeer?.equals(remotePeer) === false) {
+        throw new UnexpectedPeerError()
+      }
+
+      // 2. Create your encryption box/unbox wrapper
+      const wrapper = duplexPair<Uint8Array>()
+      const encrypt = transform<Uint8Array>() // Use transform iterables to modify data
+      const decrypt = transform<Uint8Array>()
+
+      void pipe(
+        wrapper[0], // We write to wrapper
+        encrypt, // The data is encrypted
+        shake.stream, // It goes to the remote peer
+        source => map(source, (list) => list.subarray()), // turn lists into arrays
+        decrypt, // Decrypt the incoming data
+        wrapper[0] // Pipe to the wrapper
+      )
+
+      return {
+        conn: {
+          ...wrapper[1],
+          close: async () => { },
+          localAddr: multiaddr('/ip4/127.0.0.1/tcp/4001'),
+          remoteAddr: multiaddr('/ip4/127.0.0.1/tcp/4002'),
+          timeline: {
+            open: Date.now()
+          },
+          conn: true
+        },
+        remotePeer,
+        remoteExtensions: {}
+      }
+    },
+    secureOutbound: async (localPeer, duplex, remotePeer) => {
+      // 1. Perform a basic handshake.
+      const shake = handshake<Uint8Array>(duplex)
+      shake.write(localPeer.toBytes())
+      const remoteId = await shake.read()
+
+      if (remoteId == null) {
+        throw new Error('Could not read remote ID')
+      }
+
+      shake.rest()
+
+      // 2. Create your encryption box/unbox wrapper
+      const wrapper = duplexPair<Uint8Array>()
+      const encrypt = transform<Uint8Array>()
+      const decrypt = transform<Uint8Array>()
+
+      void pipe(
+        wrapper[0], // We write to wrapper
+        encrypt, // The data is encrypted
+        shake.stream, // It goes to the remote peer
+        source => map(source, (list) => list.subarray()), // turn lists into arrays
+        decrypt, // Decrypt the incoming data
+        wrapper[0] // Pipe to the wrapper
+      )
+
+      return {
+        conn: {
+          ...wrapper[1],
+          close: async () => { },
+          localAddr: multiaddr('/ip4/127.0.0.1/tcp/4001'),
+          remoteAddr: multiaddr('/ip4/127.0.0.1/tcp/4002'),
+          timeline: {
+            open: Date.now()
+          },
+          conn: true
+        },
+        remotePeer: peerIdFromBytes(remoteId.slice()),
+        remoteExtensions: {}
+      }
+    }
+  }
+
+  return encrypter
+}

package/src/mocks/connection-gater.ts

@@ -0,0 +1,18 @@
+import type { ConnectionGater } from '@libp2p/interface/connection-gater'
+
+export function mockConnectionGater (): ConnectionGater {
+  return {
+    denyDialPeer: async () => Promise.resolve(false),
+    denyDialMultiaddr: async () => Promise.resolve(false),
+    denyInboundConnection: async () => Promise.resolve(false),
+    denyOutboundConnection: async () => Promise.resolve(false),
+    denyInboundEncryptedConnection: async () => Promise.resolve(false),
+    denyOutboundEncryptedConnection: async () => Promise.resolve(false),
+    denyInboundUpgradedConnection: async () => Promise.resolve(false),
+    denyOutboundUpgradedConnection: async () => Promise.resolve(false),
+    denyInboundRelayReservation: async () => Promise.resolve(false),
+    denyOutboundRelayedConnection: async () => Promise.resolve(false),
+    denyInboundRelayedConnection: async () => Promise.resolve(false),
+    filterMultiaddrForPeer: async () => Promise.resolve(true)
+  }
+}

package/src/mocks/connection-manager.ts

@@ -0,0 +1,211 @@
+import { CodeError } from '@libp2p/interface/errors'
+import { isPeerId, type PeerId } from '@libp2p/interface/peer-id'
+import { PeerMap } from '@libp2p/peer-collections'
+import { peerIdFromString } from '@libp2p/peer-id'
+import { isMultiaddr, type Multiaddr } from '@multiformats/multiaddr'
+import { connectionPair } from './connection.js'
+import type { Libp2pEvents, PendingDial } from '@libp2p/interface'
+import type { Connection } from '@libp2p/interface/connection'
+import type { EventEmitter } from '@libp2p/interface/events'
+import type { PubSub } from '@libp2p/interface/pubsub'
+import type { Startable } from '@libp2p/interface/startable'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
+import type { Registrar } from '@libp2p/interface-internal/registrar'
+
+export interface MockNetworkComponents {
+  peerId: PeerId
+  registrar: Registrar
+  connectionManager: ConnectionManager
+  events: EventEmitter<Libp2pEvents>
+  pubsub?: PubSub
+}
+
+class MockNetwork {
+  private components: MockNetworkComponents[] = []
+
+  addNode (components: MockNetworkComponents): void {
+    this.components.push(components)
+  }
+
+  getNode (peerId: PeerId | Multiaddr []): MockNetworkComponents {
+    if (Array.isArray(peerId) && peerId.length > 0) {
+      peerId = peerIdFromString(peerId[0].getPeerId() ?? '')
+    } else if (isPeerId(peerId)) {
+      for (const components of this.components) {
+        if (peerId.equals(components.peerId)) {
+          return components
+        }
+      }
+    }
+
+    throw new CodeError('Peer not found', 'ERR_PEER_NOT_FOUND')
+  }
+
+  reset (): void {
+    this.components = []
+  }
+}
+
+export const mockNetwork = new MockNetwork()
+
+export interface MockConnectionManagerComponents {
+  peerId: PeerId
+  registrar: Registrar
+  events: EventEmitter<Libp2pEvents>
+}
+
+class MockConnectionManager implements ConnectionManager, Startable {
+  private connections: Connection[] = []
+  private readonly components: MockConnectionManagerComponents
+  private started = false
+
+  constructor (components: MockConnectionManagerComponents) {
+    this.components = components
+  }
+
+  isStarted (): boolean {
+    return this.started
+  }
+
+  async start (): Promise<void> {
+    this.started = true
+  }
+
+  async stop (): Promise<void> {
+    for (const connection of this.connections) {
+      await this.closeConnections(connection.remotePeer)
+    }
+
+    this.started = false
+  }
+
+  getConnections (peerId?: PeerId): Connection[] {
+    if (peerId != null) {
+      return this.connections
+        .filter(c => c.remotePeer.toString() === peerId.toString())
+    }
+
+    return this.connections
+  }
+
+  getConnectionsMap (): PeerMap<Connection[]> {
+    const map = new PeerMap<Connection[]>()
+
+    for (const conn of this.connections) {
+      const conns: Connection[] = map.get(conn.remotePeer) ?? []
+      conns.push(conn)
+
+      map.set(conn.remotePeer, conns)
+    }
+
+    return map
+  }
+
+  async openConnection (peerId: PeerId | Multiaddr | Multiaddr[]): Promise<Connection> {
+    if (this.components == null) {
+      throw new CodeError('Not initialized', 'ERR_NOT_INITIALIZED')
+    }
+
+    if (isMultiaddr(peerId)) {
+      throw new CodeError('Dialing multiaddrs not supported', 'ERR_NOT_SUPPORTED')
+    }
+
+    let existingConnections: Connection[] = []
+
+    if (Array.isArray(peerId) && peerId.length > 0) {
+      existingConnections = this.getConnections(peerIdFromString(peerId[0].getPeerId() ?? ''))
+    } else if (isPeerId(peerId)) {
+      existingConnections = this.getConnections(peerId)
+    }
+
+    if (existingConnections.length > 0) {
+      return existingConnections[0]
+    }
+
+    const componentsB = mockNetwork.getNode(peerId)
+
+    const [aToB, bToA] = connectionPair(this.components, componentsB)
+
+    // track connections
+    this.connections.push(aToB)
+    ;(componentsB.connectionManager as MockConnectionManager).connections.push(bToA)
+
+    this.components.events.safeDispatchEvent('connection:open', {
+      detail: aToB
+    })
+
+    for (const protocol of this.components.registrar.getProtocols()) {
+      for (const topology of this.components.registrar.getTopologies(protocol)) {
+        topology.onConnect?.(componentsB.peerId, aToB)
+      }
+    }
+
+    this.components.events.safeDispatchEvent('peer:connect', { detail: componentsB.peerId })
+
+    componentsB.events.safeDispatchEvent('connection:open', {
+      detail: bToA
+    })
+
+    for (const protocol of componentsB.registrar.getProtocols()) {
+      for (const topology of componentsB.registrar.getTopologies(protocol)) {
+        topology.onConnect?.(this.components.peerId, bToA)
+      }
+    }
+
+    componentsB.events.safeDispatchEvent('peer:connect', { detail: this.components.peerId })
+
+    return aToB
+  }
+
+  async closeConnections (peerId: PeerId): Promise<void> {
+    if (this.components == null) {
+      throw new CodeError('Not initialized', 'ERR_NOT_INITIALIZED')
+    }
+
+    const connections = this.getConnections(peerId)
+
+    if (connections.length === 0) {
+      return
+    }
+
+    const componentsB = mockNetwork.getNode(peerId)
+
+    for (const protocol of this.components.registrar.getProtocols()) {
+      this.components.registrar.getTopologies(protocol).forEach(topology => {
+        topology.onDisconnect?.(componentsB.peerId)
+      })
+    }
+
+    for (const conn of connections) {
+      await conn.close()
+    }
+
+    this.connections = this.connections.filter(c => !c.remotePeer.equals(peerId))
+
+    if (this.connections.filter(c => !c.remotePeer.equals(peerId)).length === 0) {
+      componentsB.events.safeDispatchEvent('peer:disconnect', { detail: peerId })
+    }
+
+    await componentsB.connectionManager?.closeConnections(this.components.peerId)
+
+    if (componentsB.connectionManager?.getConnectionsMap().get(this.components.peerId) == null) {
+      componentsB.events.safeDispatchEvent('peer:disconnect', { detail: this.components.peerId })
+    }
+  }
+
+  async acceptIncomingConnection (): Promise<boolean> {
+    return true
+  }
+
+  afterUpgradeInbound (): void {
+
+  }
+
+  getDialQueue (): PendingDial[] {
+    return []
+  }
+}
+
+export function mockConnectionManager (components: MockConnectionManagerComponents): ConnectionManager {
+  return new MockConnectionManager(components)
+}