@libp2p/interface-compliance-tests 3.0.7-ab0e3980 → 3.0.7-b36ec7f2

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)
+}

package/src/mocks/connection.ts

@@ -0,0 +1,224 @@
+import { CodeError } from '@libp2p/interface/errors'
+import { logger } from '@libp2p/logger'
+import * as mss from '@libp2p/multistream-select'
+import { peerIdFromString } from '@libp2p/peer-id'
+import { duplexPair } from 'it-pair/duplex'
+import { pipe } from 'it-pipe'
+import { mockMultiaddrConnection } from './multiaddr-connection.js'
+import { mockMuxer } from './muxer.js'
+import { mockRegistrar } from './registrar.js'
+import type { AbortOptions } from '@libp2p/interface'
+import type { MultiaddrConnection, Connection, Stream, Direction, ConnectionTimeline, ConnectionStatus } from '@libp2p/interface/connection'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { StreamMuxer, StreamMuxerFactory } from '@libp2p/interface/stream-muxer'
+import type { Registrar } from '@libp2p/interface-internal/registrar'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { Duplex, Source } from 'it-stream-types'
+import type { Uint8ArrayList } from 'uint8arraylist'
+
+const log = logger('libp2p:mock-connection')
+
+export interface MockConnectionOptions {
+  direction?: Direction
+  registrar?: Registrar
+  muxerFactory?: StreamMuxerFactory
+}
+
+interface MockConnectionInit {
+  remoteAddr: Multiaddr
+  remotePeer: PeerId
+  direction: Direction
+  maConn: MultiaddrConnection
+  muxer: StreamMuxer
+}
+
+class MockConnection implements Connection {
+  public id: string
+  public remoteAddr: Multiaddr
+  public remotePeer: PeerId
+  public direction: Direction
+  public timeline: ConnectionTimeline
+  public multiplexer?: string
+  public encryption?: string
+  public status: ConnectionStatus
+  public streams: Stream[]
+  public tags: string[]
+
+  private readonly muxer: StreamMuxer
+  private readonly maConn: MultiaddrConnection
+
+  constructor (init: MockConnectionInit) {
+    const { remoteAddr, remotePeer, direction, maConn, muxer } = init
+
+    this.id = `mock-connection-${Math.random()}`
+    this.remoteAddr = remoteAddr
+    this.remotePeer = remotePeer
+    this.direction = direction
+    this.status = 'open'
+    this.direction = direction
+    this.timeline = maConn.timeline
+    this.multiplexer = 'test-multiplexer'
+    this.encryption = 'yes-yes-very-secure'
+    this.streams = []
+    this.tags = []
+    this.muxer = muxer
+    this.maConn = maConn
+  }
+
+  async newStream (protocols: string | string[], options?: AbortOptions): Promise<Stream> {
+    if (!Array.isArray(protocols)) {
+      protocols = [protocols]
+    }
+
+    if (protocols.length === 0) {
+      throw new Error('protocols must have a length')
+    }
+
+    if (this.status !== 'open') {
+      throw new CodeError('connection must be open to create streams', 'ERR_CONNECTION_CLOSED')
+    }
+
+    const id = `${Math.random()}`
+    const stream = await this.muxer.newStream(id)
+    const result = await mss.select(stream, protocols, options)
+
+    stream.protocol = result.protocol
+    stream.direction = 'outbound'
+    stream.sink = result.stream.sink
+    stream.source = result.stream.source
+
+    this.streams.push(stream)
+
+    return stream
+  }
+
+  addStream (stream: Stream): void {
+    this.streams.push(stream)
+  }
+
+  removeStream (id: string): void {
+    this.streams = this.streams.filter(stream => stream.id !== id)
+  }
+
+  async close (options?: AbortOptions): Promise<void> {
+    this.status = 'closing'
+    await Promise.all(
+      this.streams.map(async s => s.close(options))
+    )
+    await this.maConn.close()
+    this.status = 'closed'
+    this.timeline.close = Date.now()
+  }
+
+  abort (err: Error): void {
+    this.status = 'closing'
+    this.streams.forEach(s => {
+      s.abort(err)
+    })
+    this.maConn.abort(err)
+    this.status = 'closed'
+    this.timeline.close = Date.now()
+  }
+}
+
+export function mockConnection (maConn: MultiaddrConnection, opts: MockConnectionOptions = {}): Connection {
+  const remoteAddr = maConn.remoteAddr
+  const remotePeerIdStr = remoteAddr.getPeerId() ?? '12D3KooWCrhmFM1BCPGBkNzbPfDk4cjYmtAYSpZwUBC69Qg2kZyq'
+
+  if (remotePeerIdStr == null) {
+    throw new Error('Remote multiaddr must contain a peer id')
+  }
+
+  const remotePeer = peerIdFromString(remotePeerIdStr)
+  const direction = opts.direction ?? 'inbound'
+  const registrar = opts.registrar ?? mockRegistrar()
+  const muxerFactory = opts.muxerFactory ?? mockMuxer()
+
+  const muxer = muxerFactory.createStreamMuxer({
+    direction,
+    onIncomingStream: (muxedStream) => {
+      try {
+        mss.handle(muxedStream, registrar.getProtocols())
+          .then(({ stream, protocol }) => {
+            log('%s: incoming stream opened on %s', direction, protocol)
+            muxedStream.protocol = protocol
+            muxedStream.sink = stream.sink
+            muxedStream.source = stream.source
+
+            connection.addStream(muxedStream)
+            const { handler } = registrar.getHandler(protocol)
+
+            handler({ connection, stream: muxedStream })
+          }).catch(err => {
+            log.error(err)
+          })
+      } catch (err: any) {
+        log.error(err)
+      }
+    },
+    onStreamEnd: (muxedStream) => {
+      connection.removeStream(muxedStream.id)
+    }
+  })
+
+  void pipe(
+    maConn, muxer, maConn
+  )
+
+  const connection = new MockConnection({
+    remoteAddr,
+    remotePeer,
+    direction,
+    maConn,
+    muxer
+  })
+
+  return connection
+}
+
+export function mockStream (stream: Duplex<AsyncGenerator<Uint8ArrayList>, Source<Uint8ArrayList | Uint8Array>, Promise<void>>): Stream {
+  return {
+    ...stream,
+    close: async () => {},
+    closeRead: async () => {},
+    closeWrite: async () => {},
+    abort: () => {},
+    direction: 'outbound',
+    protocol: '/foo/1.0.0',
+    timeline: {
+      open: Date.now()
+    },
+    metadata: {},
+    id: `stream-${Date.now()}`,
+    status: 'open',
+    readStatus: 'ready',
+    writeStatus: 'ready'
+  }
+}
+
+export interface Peer {
+  peerId: PeerId
+  registrar: Registrar
+}
+
+export function multiaddrConnectionPair (a: { peerId: PeerId, registrar: Registrar }, b: { peerId: PeerId, registrar: Registrar }): [ MultiaddrConnection, MultiaddrConnection ] {
+  const [peerBtoPeerA, peerAtoPeerB] = duplexPair<Uint8Array>()
+
+  return [
+    mockMultiaddrConnection(peerAtoPeerB, b.peerId),
+    mockMultiaddrConnection(peerBtoPeerA, a.peerId)
+  ]
+}
+
+export function connectionPair (a: { peerId: PeerId, registrar: Registrar }, b: { peerId: PeerId, registrar: Registrar }): [ Connection, Connection ] {
+  const [peerBtoPeerA, peerAtoPeerB] = multiaddrConnectionPair(a, b)
+
+  return [
+    mockConnection(peerBtoPeerA, {
+      registrar: a.registrar
+    }),
+    mockConnection(peerAtoPeerB, {
+      registrar: b.registrar
+    })
+  ]
+}

package/src/mocks/duplex.ts

@@ -0,0 +1,10 @@
+import type { Duplex, Source } from 'it-stream-types'
+
+export function mockDuplex (): Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>> {
+  return {
+    source: (async function * () {
+      yield * []
+    }()),
+    sink: async () => {}
+  }
+}

package/src/mocks/index.ts

@@ -0,0 +1,12 @@
+export { mockConnectionEncrypter } from './connection-encrypter.js'
+export { mockConnectionGater } from './connection-gater.js'
+export { mockConnectionManager, mockNetwork } from './connection-manager.js'
+export { mockConnection, mockStream, connectionPair } from './connection.js'
+export { mockMultiaddrConnection, mockMultiaddrConnPair } from './multiaddr-connection.js'
+export { mockMuxer } from './muxer.js'
+export { mockRegistrar } from './registrar.js'
+export { mockUpgrader } from './upgrader.js'
+export { mockDuplex } from './duplex.js'
+export { mockMetrics } from './metrics.js'
+export type { MockUpgraderInit } from './upgrader.js'
+export type { MockNetworkComponents } from './connection-manager.js'

package/src/mocks/metrics.ts

@@ -0,0 +1,162 @@
+import type { MultiaddrConnection, Stream, Connection } from '@libp2p/interface/connection'
+import type { Metric, MetricGroup, StopTimer, Metrics, CalculatedMetricOptions, MetricOptions } from '@libp2p/interface/metrics'
+
+class DefaultMetric implements Metric {
+  public value: number = 0
+
+  update (value: number): void {
+    this.value = value
+  }
+
+  increment (value: number = 1): void {
+    this.value += value
+  }
+
+  decrement (value: number = 1): void {
+    this.value -= value
+  }
+
+  reset (): void {
+    this.value = 0
+  }
+
+  timer (): StopTimer {
+    const start = Date.now()
+
+    return () => {
+      this.value = Date.now() - start
+    }
+  }
+}
+
+class DefaultGroupMetric implements MetricGroup {
+  public values: Record<string, number> = {}
+
+  update (values: Record<string, number>): void {
+    Object.entries(values).forEach(([key, value]) => {
+      this.values[key] = value
+    })
+  }
+
+  increment (values: Record<string, number | unknown>): void {
+    Object.entries(values).forEach(([key, value]) => {
+      this.values[key] = this.values[key] ?? 0
+      const inc = typeof value === 'number' ? value : 1
+
+      this.values[key] += Number(inc)
+    })
+  }
+
+  decrement (values: Record<string, number | unknown>): void {
+    Object.entries(values).forEach(([key, value]) => {
+      this.values[key] = this.values[key] ?? 0
+      const dec = typeof value === 'number' ? value : 1
+
+      this.values[key] -= Number(dec)
+    })
+  }
+
+  reset (): void {
+    this.values = {}
+  }
+
+  timer (key: string): StopTimer {
+    const start = Date.now()
+
+    return () => {
+      this.values[key] = Date.now() - start
+    }
+  }
+}
+
+class MockMetrics implements Metrics {
+  public metrics = new Map<string, any>()
+
+  trackMultiaddrConnection (maConn: MultiaddrConnection): void {
+
+  }
+
+  trackProtocolStream (stream: Stream, connection: Connection): void {
+
+  }
+
+  registerMetric (name: string, opts: CalculatedMetricOptions): void
+  registerMetric (name: string, opts?: MetricOptions): Metric
+  registerMetric (name: string, opts: any): any {
+    if (name == null ?? name.trim() === '') {
+      throw new Error('Metric name is required')
+    }
+
+    if (opts?.calculate != null) {
+      // calculated metric
+      this.metrics.set(name, opts.calculate)
+      return
+    }
+
+    const metric = new DefaultMetric()
+    this.metrics.set(name, metric)
+
+    return metric
+  }
+
+  registerCounter (name: string, opts: CalculatedMetricOptions): void
+  registerCounter (name: string, opts?: MetricOptions): Metric
+  registerCounter (name: string, opts: any): any {
+    if (name == null ?? name.trim() === '') {
+      throw new Error('Metric name is required')
+    }
+
+    if (opts?.calculate != null) {
+      // calculated metric
+      this.metrics.set(name, opts.calculate)
+      return
+    }
+
+    const metric = new DefaultMetric()
+    this.metrics.set(name, metric)
+
+    return metric
+  }
+
+  registerMetricGroup (name: string, opts: CalculatedMetricOptions<Record<string, number>>): void
+  registerMetricGroup (name: string, opts?: MetricOptions): MetricGroup
+  registerMetricGroup (name: string, opts: any): any {
+    if (name == null ?? name.trim() === '') {
+      throw new Error('Metric name is required')
+    }
+
+    if (opts?.calculate != null) {
+      // calculated metric
+      this.metrics.set(name, opts.calculate)
+      return
+    }
+
+    const metric = new DefaultGroupMetric()
+    this.metrics.set(name, metric)
+
+    return metric
+  }
+
+  registerCounterGroup (name: string, opts: CalculatedMetricOptions<Record<string, number>>): void
+  registerCounterGroup (name: string, opts?: MetricOptions): MetricGroup
+  registerCounterGroup (name: string, opts: any): any {
+    if (name == null ?? name.trim() === '') {
+      throw new Error('Metric name is required')
+    }
+
+    if (opts?.calculate != null) {
+      // calculated metric
+      this.metrics.set(name, opts.calculate)
+      return
+    }
+
+    const metric = new DefaultGroupMetric()
+    this.metrics.set(name, metric)
+
+    return metric
+  }
+}
+
+export function mockMetrics (): () => Metrics {
+  return () => new MockMetrics()
+}

package/src/mocks/multiaddr-connection.ts

@@ -0,0 +1,76 @@
+import { multiaddr } from '@multiformats/multiaddr'
+import { abortableSource } from 'abortable-iterator'
+import { duplexPair } from 'it-pair/duplex'
+import type { MultiaddrConnection } from '@libp2p/interface/connection'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { Duplex } from 'it-stream-types'
+
+export function mockMultiaddrConnection (source: Duplex<AsyncGenerator<Uint8Array>> & Partial<MultiaddrConnection>, peerId: PeerId): MultiaddrConnection {
+  const maConn: MultiaddrConnection = {
+    async close () {
+
+    },
+    abort: () => {},
+    timeline: {
+      open: Date.now()
+    },
+    remoteAddr: multiaddr(`/ip4/127.0.0.1/tcp/4001/p2p/${peerId.toString()}`),
+    ...source
+  }
+
+  return maConn
+}
+
+export interface MockMultiaddrConnPairOptions {
+  addrs: Multiaddr[]
+  remotePeer: PeerId
+}
+
+/**
+ * Returns both sides of a mocked MultiaddrConnection
+ */
+export function mockMultiaddrConnPair (opts: MockMultiaddrConnPairOptions): { inbound: MultiaddrConnection, outbound: MultiaddrConnection } {
+  const { addrs, remotePeer } = opts
+  const controller = new AbortController()
+  const [localAddr, remoteAddr] = addrs
+  const [inboundStream, outboundStream] = duplexPair<Uint8Array>()
+
+  const outbound: MultiaddrConnection = {
+    ...outboundStream,
+    remoteAddr: remoteAddr.toString().includes(`/p2p/${remotePeer.toString()}`) ? remoteAddr : remoteAddr.encapsulate(`/p2p/${remotePeer.toString()}`),
+    timeline: {
+      open: Date.now()
+    },
+    close: async () => {
+      outbound.timeline.close = Date.now()
+      controller.abort()
+    },
+    abort: (err: Error) => {
+      outbound.timeline.close = Date.now()
+      controller.abort(err)
+    }
+  }
+
+  const inbound: MultiaddrConnection = {
+    ...inboundStream,
+    remoteAddr: localAddr,
+    timeline: {
+      open: Date.now()
+    },
+    close: async () => {
+      inbound.timeline.close = Date.now()
+      controller.abort()
+    },
+    abort: (err: Error) => {
+      outbound.timeline.close = Date.now()
+      controller.abort(err)
+    }
+  }
+
+  // Make the sources abortable so we can close them easily
+  inbound.source = abortableSource(inbound.source, controller.signal)
+  outbound.source = abortableSource(outbound.source, controller.signal)
+
+  return { inbound, outbound }
+}