@libp2p/interface-compliance-tests 2.0.2 → 3.0.1

package/src/mocks/connection.ts

@@ -1,205 +0,0 @@
-import { peerIdFromString } from '@libp2p/peer-id'
-import { pipe } from 'it-pipe'
-import { duplexPair } from 'it-pair/duplex'
-import type { MultiaddrConnection } from '@libp2p/interfaces/transport'
-import type { Connection, Stream, Metadata, ProtocolStream, ConnectionStat } from '@libp2p/interfaces/connection'
-import type { Duplex } from 'it-stream-types'
-import { mockMuxer } from './muxer.js'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
-import { mockMultiaddrConnection } from './multiaddr-connection.js'
-import type { Registrar } from '@libp2p/interfaces/registrar'
-import { mockRegistrar } from './registrar.js'
-import { Dialer, Listener } from '@libp2p/multistream-select'
-import { logger } from '@libp2p/logger'
-import * as STATUS from '@libp2p/interfaces/connection/status'
-import type { Multiaddr } from '@multiformats/multiaddr'
-import type { StreamMuxer } from '@libp2p/interfaces/stream-muxer'
-import { Components } from '@libp2p/interfaces/components'
-import type { AbortOptions } from '@libp2p/interfaces'
-
-const log = logger('libp2p:mock-connection')
-
-export interface MockConnectionOptions {
-  direction?: 'inbound' | 'outbound'
-  registrar?: Registrar
-}
-
-interface MockConnectionInit {
-  remoteAddr: Multiaddr
-  remotePeer: PeerId
-  direction: 'inbound' | 'outbound'
-  maConn: MultiaddrConnection
-  muxer: StreamMuxer
-}
-
-class MockConnection implements Connection {
-  public id: string
-  public remoteAddr: Multiaddr
-  public remotePeer: PeerId
-  public direction: 'inbound' | 'outbound'
-  public stat: ConnectionStat
-  public registry: Map<string, Metadata>
-  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.stat = {
-      status: STATUS.OPEN,
-      direction,
-      timeline: maConn.timeline,
-      multiplexer: 'test-multiplexer',
-      encryption: 'yes-yes-very-secure'
-    }
-    this.registry = new Map()
-    this.streams = []
-    this.tags = []
-    this.muxer = muxer
-    this.maConn = maConn
-  }
-
-  async newStream (protocols: string | string[], options?: AbortOptions) {
-    if (!Array.isArray(protocols)) {
-      protocols = [protocols]
-    }
-
-    if (protocols.length === 0) {
-      throw new Error('protocols must have a length')
-    }
-
-    const id = `${Math.random()}`
-    const stream: Stream = this.muxer.newStream(id)
-    const mss = new Dialer(stream)
-    const result = await mss.select(protocols, options)
-
-    const streamData: ProtocolStream = {
-      protocol: result.protocol,
-      stream: {
-        ...stream,
-        ...result.stream
-      }
-    }
-
-    this.addStream(stream, { protocol: result.protocol, metadata: {} })
-
-    return streamData
-  }
-
-  addStream (stream: Stream, metadata: Partial<Metadata>) {
-    this.registry.set(stream.id, {
-      protocol: metadata.protocol ?? '',
-      metadata: metadata.metadata ?? {}
-    })
-
-    this.streams.push(stream)
-  }
-
-  removeStream (id: string) {
-    this.registry.delete(id)
-    this.streams = this.streams.filter(stream => stream.id !== id)
-  }
-
-  async close () {
-    this.stat.status = STATUS.CLOSING
-    await this.maConn.close()
-    this.stat.status = STATUS.CLOSED
-  }
-}
-
-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 = mockMuxer()
-
-  const muxer = muxerFactory.createStreamMuxer(new Components(), {
-    onIncomingStream: (muxedStream) => {
-      const mss = new Listener(muxedStream)
-      try {
-        mss.handle(registrar.getProtocols())
-          .then(({ stream, protocol }) => {
-            log('%s: incoming stream opened on %s', direction, protocol)
-            muxedStream = { ...muxedStream, ...stream }
-
-            connection.addStream(muxedStream, { protocol, metadata: {} })
-            const handler = registrar.getHandler(protocol)
-
-            handler({ connection, stream: muxedStream, protocol })
-          }).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<Uint8Array>): Stream {
-  return {
-    ...stream,
-    close: () => {},
-    closeRead: () => {},
-    closeWrite: () => {},
-    abort: () => {},
-    reset: () => {},
-    timeline: {
-      open: Date.now()
-    },
-    id: `stream-${Date.now()}`
-  }
-}
-
-export interface Peer {
-  peerId: PeerId
-  registrar: Registrar
-}
-
-export function connectionPair (a: Components, b: Components): [ Connection, Connection ] {
-  const [peerBtoPeerA, peerAtoPeerB] = duplexPair<Uint8Array>()
-
-  return [
-    mockConnection(
-      mockMultiaddrConnection(peerAtoPeerB, b.getPeerId()), {
-        registrar: a.getRegistrar()
-      }
-    ),
-    mockConnection(
-      mockMultiaddrConnection(peerBtoPeerA, a.getPeerId()), {
-        registrar: b.getRegistrar()
-      }
-    )
-  ]
-}

package/src/mocks/duplex.ts

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

package/src/mocks/index.ts

@@ -1,10 +0,0 @@
-
-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 type { MockUpgraderInit } from './upgrader.js'

package/src/mocks/multiaddr-connection.ts

@@ -1,66 +0,0 @@
-import { Multiaddr } from '@multiformats/multiaddr'
-import { duplexPair } from 'it-pair/duplex'
-import { abortableSource } from 'abortable-iterator'
-import type { MultiaddrConnection } from '@libp2p/interfaces/transport'
-import type { Duplex } from 'it-stream-types'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
-
-export function mockMultiaddrConnection (source: Duplex<Uint8Array> & Partial<MultiaddrConnection>, peerId: PeerId): MultiaddrConnection {
-  const maConn: MultiaddrConnection = {
-    async close () {
-
-    },
-    timeline: {
-      open: Date.now()
-    },
-    remoteAddr: new 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.encapsulate(`/p2p/${remotePeer.toString()}`),
-    timeline: {
-      open: Date.now()
-    },
-    close: async () => {
-      outbound.timeline.close = Date.now()
-      controller.abort()
-    }
-  }
-
-  const inbound: MultiaddrConnection = {
-    ...inboundStream,
-    remoteAddr: localAddr,
-    timeline: {
-      open: Date.now()
-    },
-    close: async () => {
-      inbound.timeline.close = Date.now()
-      controller.abort()
-    }
-  }
-
-  // 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 }
-}

package/src/mocks/muxer.ts

@@ -1,424 +0,0 @@
-import { Pushable, pushable } from 'it-pushable'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { abortableSource } from 'abortable-iterator'
-import { anySignal } from 'any-signal'
-import errCode from 'err-code'
-import { Logger, logger } from '@libp2p/logger'
-import * as ndjson from 'it-ndjson'
-import type { Stream } from '@libp2p/interfaces/connection'
-import type { StreamMuxer, StreamMuxerFactory, StreamMuxerInit } from '@libp2p/interfaces/stream-muxer'
-import type { Source } from 'it-stream-types'
-import { pipe } from 'it-pipe'
-import map from 'it-map'
-import type { Components } from '@libp2p/interfaces/components'
-import { Uint8ArrayList } from 'uint8arraylist'
-
-let muxers = 0
-let streams = 0
-const MAX_MESSAGE_SIZE = 1024 * 1024
-
-interface DataMessage {
-  id: string
-  type: 'data'
-  direction: 'initiator' | 'recipient'
-  chunk: string
-}
-
-interface ResetMessage {
-  id: string
-  type: 'reset'
-  direction: 'initiator' | 'recipient'
-}
-
-interface CloseMessage {
-  id: string
-  type: 'close'
-  direction: 'initiator' | 'recipient'
-}
-
-interface CreateMessage {
-  id: string
-  type: 'create'
-  direction: 'initiator'
-}
-
-type StreamMessage = DataMessage | ResetMessage | CloseMessage | CreateMessage
-
-class MuxedStream {
-  public id: string
-  public input: Pushable<Uint8Array>
-  public stream: Stream
-  public type: 'initiator' | 'recipient'
-
-  private sinkEnded: boolean
-  private sourceEnded: boolean
-  private readonly abortController: AbortController
-  private readonly resetController: AbortController
-  private readonly closeController: AbortController
-  private readonly log: Logger
-
-  constructor (init: { id: string, type: 'initiator' | 'recipient', push: Pushable<StreamMessage>, onEnd: (err?: Error) => void }) {
-    const { id, type, push, onEnd } = init
-
-    this.log = logger(`libp2p:mock-muxer:stream:${id}:${type}`)
-
-    this.id = id
-    this.type = type
-    this.abortController = new AbortController()
-    this.resetController = new AbortController()
-    this.closeController = new AbortController()
-
-    this.sourceEnded = false
-    this.sinkEnded = false
-
-    let endErr: Error | undefined
-
-    const onSourceEnd = (err?: Error) => {
-      if (this.sourceEnded) {
-        return
-      }
-
-      this.log('onSourceEnd sink ended? %s', this.sinkEnded)
-
-      this.sourceEnded = true
-
-      if (err != null && endErr == null) {
-        endErr = err
-      }
-
-      if (this.sinkEnded) {
-        this.stream.timeline.close = Date.now()
-
-        if (onEnd != null) {
-          onEnd(endErr)
-        }
-      }
-    }
-
-    const onSinkEnd = (err?: Error) => {
-      if (this.sinkEnded) {
-        return
-      }
-
-      this.log('onSinkEnd source ended? %s', this.sourceEnded)
-
-      this.sinkEnded = true
-
-      if (err != null && endErr == null) {
-        endErr = err
-      }
-
-      if (this.sourceEnded) {
-        this.stream.timeline.close = Date.now()
-
-        if (onEnd != null) {
-          onEnd(endErr)
-        }
-      }
-    }
-
-    this.input = pushable<Uint8Array>({
-      onEnd: onSourceEnd
-    })
-
-    this.stream = {
-      id,
-      sink: async (source) => {
-        if (this.sinkEnded) {
-          throw errCode(new Error('stream closed for writing'), 'ERR_SINK_ENDED')
-        }
-
-        source = abortableSource(source, anySignal([
-          this.abortController.signal,
-          this.resetController.signal,
-          this.closeController.signal
-        ]))
-
-        try {
-          if (this.type === 'initiator') {
-            // If initiator, open a new stream
-            const createMsg: CreateMessage = {
-              id: this.id,
-              type: 'create',
-              direction: this.type
-            }
-            push.push(createMsg)
-          }
-
-          const list = new Uint8ArrayList()
-
-          for await (const chunk of source) {
-            list.append(chunk)
-
-            while (list.length > 0) {
-              const available = Math.min(list.length, MAX_MESSAGE_SIZE)
-              const subList = list.subarray(0, available)
-              const dataMsg: DataMessage = {
-                id,
-                type: 'data',
-                chunk: uint8ArrayToString(subList.slice(), 'base64'),
-                direction: this.type
-              }
-
-              push.push(dataMsg)
-              list.consume(available)
-            }
-          }
-        } catch (err: any) {
-          if (err.type === 'aborted' && err.message === 'The operation was aborted') {
-            if (this.closeController.signal.aborted) {
-              return
-            }
-
-            if (this.resetController.signal.aborted) {
-              err.message = 'stream reset'
-              err.code = 'ERR_STREAM_RESET'
-            }
-
-            if (this.abortController.signal.aborted) {
-              err.message = 'stream aborted'
-              err.code = 'ERR_STREAM_ABORT'
-            }
-          }
-
-          // Send no more data if this stream was remotely reset
-          if (err.code !== 'ERR_STREAM_RESET') {
-            const resetMsg: ResetMessage = {
-              id,
-              type: 'reset',
-              direction: this.type
-            }
-            push.push(resetMsg)
-          }
-
-          this.log('sink erred', err)
-
-          this.input.end(err)
-          onSinkEnd(err)
-          return
-        }
-
-        this.log('sink ended')
-
-        onSinkEnd()
-
-        const closeMsg: CloseMessage = {
-          id,
-          type: 'close',
-          direction: this.type
-        }
-        push.push(closeMsg)
-      },
-      source: this.input,
-
-      // Close for reading
-      close: () => {
-        this.stream.closeRead()
-        this.stream.closeWrite()
-      },
-
-      closeRead: () => {
-        this.input.end()
-      },
-
-      closeWrite: () => {
-        this.closeController.abort()
-
-        const closeMsg: CloseMessage = {
-          id,
-          type: 'close',
-          direction: this.type
-        }
-        push.push(closeMsg)
-        onSinkEnd()
-      },
-
-      // Close for reading and writing (local error)
-      abort: (err: Error) => {
-        // End the source with the passed error
-        this.input.end(err)
-        this.abortController.abort()
-        onSinkEnd(err)
-      },
-
-      // Close immediately for reading and writing (remote error)
-      reset: () => {
-        const err = errCode(new Error('stream reset'), 'ERR_STREAM_RESET')
-        this.resetController.abort()
-        this.input.end(err)
-        onSinkEnd(err)
-      },
-      timeline: {
-        open: Date.now()
-      }
-    }
-  }
-}
-
-class MockMuxer implements StreamMuxer {
-  public source: Source<Uint8Array>
-  public input: Pushable<Uint8Array>
-  public streamInput: Pushable<StreamMessage>
-  public name: string
-  public protocol: string = '/mock-muxer/1.0.0'
-
-  private readonly registryInitiatorStreams: Map<string, MuxedStream>
-  private readonly registryRecipientStreams: Map<string, MuxedStream>
-  private readonly options: StreamMuxerInit
-
-  private readonly log: Logger
-
-  constructor (init?: StreamMuxerInit) {
-    this.name = `muxer:${muxers++}`
-    this.log = logger(`libp2p:mock-muxer:${this.name}`)
-    this.registryInitiatorStreams = new Map()
-    this.registryRecipientStreams = new Map()
-    this.log('create muxer')
-    this.options = init ?? {}
-    // receives data from the muxer at the other end of the stream
-    this.source = this.input = pushable<Uint8Array>({
-      onEnd: (err) => {
-        this.log('closing muxed streams')
-        for (const stream of this.streams) {
-          if (err == null) {
-            stream.close()
-          } else {
-            stream.abort(err)
-          }
-        }
-      }
-    })
-
-    // receives messages from all of the muxed streams
-    this.streamInput = pushable<StreamMessage>()
-  }
-
-  // receive incoming messages
-  async sink (source: Source<Uint8Array>) {
-    try {
-      await pipe(
-        source,
-        (source) => map(source, buf => uint8ArrayToString(buf)),
-        ndjson.parse,
-        async (source) => {
-          for await (const message of source) {
-            this.log.trace('-> %s %s %s', message.type, message.direction, message.id)
-            this.handleMessage(message)
-          }
-        }
-      )
-
-      this.log('muxed stream ended')
-      this.input.end()
-    } catch (err: any) {
-      this.log('muxed stream errored', err)
-      this.input.end(err)
-    }
-  }
-
-  handleMessage (message: StreamMessage) {
-    let muxedStream: MuxedStream | undefined
-
-    const registry = message.direction === 'initiator' ? this.registryRecipientStreams : this.registryInitiatorStreams
-
-    if (message.type === 'create') {
-      if (registry.has(message.id)) {
-        throw new Error(`Already had stream for ${message.id}`)
-      }
-
-      muxedStream = this.createStream(message.id, 'recipient')
-      registry.set(muxedStream.stream.id, muxedStream)
-
-      if (this.options.onIncomingStream != null) {
-        this.options.onIncomingStream(muxedStream.stream)
-      }
-    }
-
-    muxedStream = registry.get(message.id)
-
-    if (muxedStream == null) {
-      this.log.error(`No stream found for ${message.id}`)
-
-      return
-    }
-
-    if (message.type === 'data') {
-      muxedStream.input.push(uint8ArrayFromString(message.chunk, 'base64'))
-    } else if (message.type === 'reset') {
-      this.log('-> reset stream %s %s', muxedStream.type, muxedStream.stream.id)
-      muxedStream.stream.reset()
-    } else if (message.type === 'close') {
-      this.log('-> closing stream %s %s', muxedStream.type, muxedStream.stream.id)
-      void muxedStream.stream.close()
-    }
-  }
-
-  get streams () {
-    return Array.from(this.registryRecipientStreams.values())
-      .concat(Array.from(this.registryInitiatorStreams.values()))
-      .map(({ stream }) => stream)
-  }
-
-  newStream (name?: string) {
-    this.log('newStream %s', name)
-    const storedStream = this.createStream(name, 'initiator')
-    this.registryInitiatorStreams.set(storedStream.stream.id, storedStream)
-
-    return storedStream.stream
-  }
-
-  createStream (name?: string, type: 'initiator' | 'recipient' = 'initiator'): MuxedStream {
-    const id = name ?? `${this.name}:stream:${streams++}`
-
-    this.log('createStream %s %s', type, id)
-
-    const muxedStream: MuxedStream = new MuxedStream({
-      id,
-      type,
-      push: this.streamInput,
-      onEnd: () => {
-        this.log('stream ended %s %s', type, id)
-
-        if (type === 'initiator') {
-          this.registryInitiatorStreams.delete(id)
-        } else {
-          this.registryRecipientStreams.delete(id)
-        }
-
-        if (this.options.onStreamEnd != null) {
-          this.options.onStreamEnd(muxedStream.stream)
-        }
-      }
-    })
-
-    return muxedStream
-  }
-}
-
-class MockMuxerFactory implements StreamMuxerFactory {
-  public protocol: string = '/mock-muxer/1.0.0'
-
-  createStreamMuxer (c: Components, init?: StreamMuxerInit): StreamMuxer {
-    const mockMuxer = new MockMuxer(init)
-
-    void Promise.resolve().then(async () => {
-      void pipe(
-        mockMuxer.streamInput,
-        ndjson.stringify,
-        (source) => map(source, str => uint8ArrayFromString(str)),
-        async (source) => {
-          for await (const buf of source) {
-            mockMuxer.input.push(buf)
-          }
-        }
-      )
-    })
-
-    return mockMuxer
-  }
-}
-
-export function mockMuxer (): MockMuxerFactory {
-  return new MockMuxerFactory()
-}