@libp2p/interface-compliance-tests 6.5.0 → 7.0.0-049bfa0fa

package/src/mocks/muxer.ts

@@ -1,331 +0,0 @@
-import { defaultLogger, logger } from '@libp2p/logger'
-import { AbstractStream } from '@libp2p/utils/abstract-stream'
-import { abortableSource } from 'abortable-iterator'
-import map from 'it-map'
-import * as ndjson from 'it-ndjson'
-import { pipe } from 'it-pipe'
-import { pushable } from 'it-pushable'
-import { Uint8ArrayList } from 'uint8arraylist'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import type { AbortOptions, Direction, Stream, StreamMuxer, StreamMuxerFactory, StreamMuxerInit } from '@libp2p/interface'
-import type { Logger } from '@libp2p/logger'
-import type { AbstractStreamInit } from '@libp2p/utils/abstract-stream'
-import type { Pushable } from 'it-pushable'
-import type { Source } from 'it-stream-types'
-
-let muxers = 0
-let streams = 0
-
-interface DataMessage {
-  id: string
-  type: 'data'
-  direction: Direction
-  chunk: string
-}
-
-interface ResetMessage {
-  id: string
-  type: 'reset'
-  direction: Direction
-}
-
-interface CloseWriteMessage {
-  id: string
-  type: 'closeWrite'
-  direction: Direction
-}
-
-interface CloseReadMessage {
-  id: string
-  type: 'closeRead'
-  direction: Direction
-}
-
-interface CreateMessage {
-  id: string
-  type: 'create'
-  direction: 'outbound'
-}
-
-type StreamMessage = DataMessage | ResetMessage | CloseWriteMessage | CloseReadMessage | CreateMessage
-
-export interface MockMuxedStreamInit extends AbstractStreamInit {
-  push: Pushable<StreamMessage>
-}
-
-class MuxedStream extends AbstractStream {
-  private readonly push: Pushable<StreamMessage>
-
-  constructor (init: MockMuxedStreamInit) {
-    super(init)
-
-    this.push = init.push
-  }
-
-  sendNewStream (): void {
-    // If initiator, open a new stream
-    const createMsg: CreateMessage = {
-      id: this.id,
-      type: 'create',
-      direction: 'outbound'
-    }
-    this.push.push(createMsg)
-  }
-
-  sendData (data: Uint8ArrayList): void {
-    const dataMsg: DataMessage = {
-      id: this.id,
-      type: 'data',
-      chunk: uint8ArrayToString(data.subarray(), 'base64pad'),
-      direction: this.direction
-    }
-    this.push.push(dataMsg)
-  }
-
-  sendReset (): void {
-    const resetMsg: ResetMessage = {
-      id: this.id,
-      type: 'reset',
-      direction: this.direction
-    }
-    this.push.push(resetMsg)
-  }
-
-  sendCloseWrite (): void {
-    const closeMsg: CloseWriteMessage = {
-      id: this.id,
-      type: 'closeWrite',
-      direction: this.direction
-    }
-    this.push.push(closeMsg)
-  }
-
-  sendCloseRead (): void {
-    const closeMsg: CloseReadMessage = {
-      id: this.id,
-      type: 'closeRead',
-      direction: this.direction
-    }
-    this.push.push(closeMsg)
-  }
-}
-
-class MockMuxer implements StreamMuxer {
-  public source: AsyncGenerator<Uint8Array>
-  public input: Pushable<Uint8Array>
-  public streamInput: Pushable<StreamMessage>
-  public name: string
-  public protocol: string = '/mock-muxer/1.0.0'
-
-  private readonly closeController: AbortController
-  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 ?? { direction: 'inbound', log: defaultLogger().forComponent('mock-muxer') }
-    this.closeController = new AbortController()
-    // receives data from the muxer at the other end of the stream
-    this.source = this.input = pushable({
-      onEnd: () => {
-        for (const stream of this.registryInitiatorStreams.values()) {
-          stream.destroy()
-        }
-
-        for (const stream of this.registryRecipientStreams.values()) {
-          stream.destroy()
-        }
-      }
-    })
-
-    // receives messages from all of the muxed streams
-    this.streamInput = pushable<StreamMessage>({
-      objectMode: true
-    })
-  }
-
-  // receive incoming messages
-  async sink (source: Source<Uint8ArrayList | Uint8Array>): Promise<void> {
-    try {
-      await pipe(
-        abortableSource(source, this.closeController.signal),
-        (source) => map(source, buf => uint8ArrayToString(buf.subarray())),
-        ndjson.parse<StreamMessage>,
-        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('muxer ended')
-      this.input.end()
-    } catch (err: any) {
-      this.log.error('muxer errored - %e', err)
-      this.input.end(err)
-    }
-  }
-
-  handleMessage (message: StreamMessage): void {
-    let muxedStream: MuxedStream | undefined
-
-    const registry = message.direction === 'outbound' ? 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, 'inbound')
-      registry.set(muxedStream.id, muxedStream)
-
-      if (this.options.onIncomingStream != null) {
-        this.options.onIncomingStream(muxedStream)
-      }
-    }
-
-    muxedStream = registry.get(message.id)
-
-    if (muxedStream == null) {
-      this.log.error(`No stream found for ${message.id}`)
-
-      return
-    }
-
-    if (message.type === 'data') {
-      muxedStream.sourcePush(new Uint8ArrayList(uint8ArrayFromString(message.chunk, 'base64pad')))
-    } else if (message.type === 'reset') {
-      this.log('-> reset stream %s %s', muxedStream.direction, muxedStream.id)
-      muxedStream.reset()
-    } 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()
-    }
-  }
-
-  get streams (): Stream[] {
-    return Array.from(this.registryRecipientStreams.values())
-      .concat(Array.from(this.registryInitiatorStreams.values()))
-  }
-
-  newStream (name?: string): Stream {
-    if (this.closeController.signal.aborted) {
-      throw new Error('Muxer already closed')
-    }
-    this.log('newStream %s', name)
-    const storedStream = this.createStream(name, 'outbound')
-    this.registryInitiatorStreams.set(storedStream.id, storedStream)
-
-    return storedStream
-  }
-
-  createStream (name?: string, direction: Direction = 'outbound'): MuxedStream {
-    const id = name ?? `${streams++}`
-
-    this.log('createStream %s %s', direction, id)
-
-    const muxedStream: MuxedStream = new MuxedStream({
-      id,
-      direction,
-      push: this.streamInput,
-      onEnd: () => {
-        this.log('stream ended')
-
-        if (direction === 'outbound') {
-          this.registryInitiatorStreams.delete(muxedStream.id)
-        } else {
-          this.registryRecipientStreams.delete(muxedStream.id)
-        }
-
-        if (this.options.onStreamEnd != null) {
-          this.options.onStreamEnd(muxedStream)
-        }
-      },
-      log: logger(`libp2p:mock-muxer:stream:${direction}:${id}`)
-    })
-
-    return muxedStream
-  }
-
-  async close (options?: AbortOptions): Promise<void> {
-    if (this.closeController.signal.aborted) {
-      return
-    }
-
-    const signal = options?.signal ?? AbortSignal.timeout(10)
-
-    try {
-      // try to gracefully close all streams
-      await Promise.all(
-        this.streams.map(async s => s.close({
-          signal
-        }))
-      )
-
-      this.input.end()
-
-      // try to gracefully close the muxer
-      await this.input.onEmpty({
-        signal
-      })
-
-      this.closeController.abort()
-    } catch (err: any) {
-      this.abort(err)
-    }
-  }
-
-  abort (err: Error): void {
-    if (this.closeController.signal.aborted) {
-      return
-    }
-
-    this.log('aborting muxed streams')
-
-    this.streams.forEach(s => {
-      s.abort(err)
-    })
-
-    this.closeController.abort(err)
-    this.input.end(err)
-  }
-}
-
-class MockMuxerFactory implements StreamMuxerFactory {
-  public protocol: string = '/mock-muxer/1.0.0'
-
-  createStreamMuxer (init?: StreamMuxerInit): StreamMuxer {
-    const mockMuxer = new MockMuxer(init)
-
-    void Promise.resolve().then(async () => {
-      void pipe(
-        mockMuxer.streamInput,
-        ndjson.stringify,
-        (source) => map(source, str => new Uint8ArrayList(uint8ArrayFromString(str))),
-        async (source) => {
-          for await (const buf of source) {
-            mockMuxer.input.push(buf.subarray())
-          }
-        }
-      )
-    })
-
-    return mockMuxer
-  }
-}
-
-export function mockMuxer (): StreamMuxerFactory {
-  return new MockMuxerFactory()
-}

package/src/mocks/registrar.ts

@@ -1,86 +0,0 @@
-import { mergeOptions } from '@libp2p/utils/merge-options'
-import type { Connection, PeerId, Topology, IncomingStreamData, StreamHandler, StreamHandlerOptions, StreamHandlerRecord } from '@libp2p/interface'
-import type { Registrar } from '@libp2p/interface-internal'
-
-export class MockRegistrar implements Registrar {
-  private readonly topologies = new Map<string, Array<{ id: string, topology: Topology }>>()
-  private readonly handlers = new Map<string, StreamHandlerRecord>()
-
-  getProtocols (): string[] {
-    return Array.from(this.handlers.keys()).sort()
-  }
-
-  async handle (protocol: string, handler: StreamHandler, opts?: StreamHandlerOptions): Promise<void> {
-    const options = mergeOptions.bind({ ignoreUndefined: true })({
-      maxInboundStreams: 1,
-      maxOutboundStreams: 1
-    }, opts)
-
-    if (this.handlers.has(protocol)) {
-      throw new Error(`Handler already registered for protocol ${protocol}`)
-    }
-
-    this.handlers.set(protocol, {
-      handler,
-      options
-    })
-  }
-
-  async unhandle (protocol: string): Promise<void> {
-    this.handlers.delete(protocol)
-  }
-
-  getHandler (protocol: string): StreamHandlerRecord {
-    const handler = this.handlers.get(protocol)
-
-    if (handler == null) {
-      throw new Error(`No handler registered for protocol ${protocol}`)
-    }
-
-    return handler
-  }
-
-  async register (protocol: string, topology: Topology): Promise<string> {
-    const id = `topology-id-${Math.random()}`
-    let topologies = this.topologies.get(protocol)
-
-    if (topologies == null) {
-      topologies = []
-    }
-
-    topologies.push({
-      id,
-      topology
-    })
-
-    this.topologies.set(protocol, topologies)
-
-    return id
-  }
-
-  unregister (id: string | string[]): void {
-    if (!Array.isArray(id)) {
-      id = [id]
-    }
-
-    id.forEach(id => this.topologies.delete(id))
-  }
-
-  getTopologies (protocol: string): Topology[] {
-    return (this.topologies.get(protocol) ?? []).map(t => t.topology)
-  }
-}
-
-export function mockRegistrar (): Registrar {
-  return new MockRegistrar()
-}
-
-export async function mockIncomingStreamEvent (protocol: string, conn: Connection, remotePeer: PeerId): Promise<IncomingStreamData> {
-  return {
-    ...await conn.newStream([protocol]),
-    // @ts-expect-error incomplete implementation
-    connection: {
-      remotePeer
-    }
-  }
-}

package/src/mocks/upgrader.ts

@@ -1,65 +0,0 @@
-import { anySignal } from 'any-signal'
-import { setMaxListeners } from 'main-event'
-import { mockConnection } from './connection.js'
-import type { Libp2pEvents, Connection, MultiaddrConnection, Upgrader, UpgraderOptions, ClearableSignal, ConnectionEncrypter, StreamMuxerFactory } from '@libp2p/interface'
-import type { Registrar } from '@libp2p/interface-internal'
-import type { TypedEventTarget } from 'main-event'
-
-export interface MockUpgraderInit {
-  registrar?: Registrar
-  events?: TypedEventTarget<Libp2pEvents>
-}
-
-class MockUpgrader implements Upgrader {
-  private readonly registrar?: Registrar
-  private readonly events?: TypedEventTarget<Libp2pEvents>
-
-  constructor (init: MockUpgraderInit) {
-    this.registrar = init.registrar
-    this.events = init.events
-  }
-
-  async upgradeOutbound (multiaddrConnection: MultiaddrConnection, opts: UpgraderOptions): Promise<Connection> {
-    const connection = mockConnection(multiaddrConnection, {
-      direction: 'outbound',
-      registrar: this.registrar,
-      ...opts
-    })
-
-    this.events?.safeDispatchEvent('connection:open', { detail: connection })
-
-    return connection
-  }
-
-  async upgradeInbound (multiaddrConnection: MultiaddrConnection, opts: UpgraderOptions): Promise<void> {
-    const connection = mockConnection(multiaddrConnection, {
-      direction: 'inbound',
-      registrar: this.registrar,
-      ...opts
-    })
-
-    this.events?.safeDispatchEvent('connection:open', { detail: connection })
-  }
-
-  createInboundAbortSignal (signal?: AbortSignal): ClearableSignal {
-    const output = anySignal([
-      AbortSignal.timeout(10_000),
-      signal
-    ])
-    setMaxListeners(Infinity, output)
-
-    return output
-  }
-
-  getConnectionEncrypters (): Map<string, ConnectionEncrypter<unknown>> {
-    return new Map()
-  }
-
-  getStreamMuxers (): Map<string, StreamMuxerFactory> {
-    return new Map()
-  }
-}
-
-export function mockUpgrader (init: MockUpgraderInit = {}): Upgrader {
-  return new MockUpgrader(init)
-}

package/src/pubsub/api.ts

@@ -1,116 +0,0 @@
-import { isPubSub, isStartable, start, stop } from '@libp2p/interface'
-import { expect } from 'aegir/chai'
-import delay from 'delay'
-import pDefer from 'p-defer'
-import pWaitFor from 'p-wait-for'
-import sinon from 'sinon'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { mockNetwork } from '../mocks/index.js'
-import { createComponents } from './utils.js'
-import type { PubSubArgs, PubSubComponents } from './index.js'
-import type { TestSetup } from '../index.js'
-import type { PubSub } from '@libp2p/interface'
-
-const topic = 'foo'
-const data = uint8ArrayFromString('bar')
-
-export default (common: TestSetup<PubSub, PubSubArgs>): void => {
-  describe('pubsub api', () => {
-    let pubsub: PubSub
-    let components: PubSubComponents
-
-    // Create pubsub router
-    beforeEach(async () => {
-      mockNetwork.reset()
-      components = await createComponents()
-
-      pubsub = components.pubsub = await common.setup({
-        components,
-        init: {
-          emitSelf: true
-        }
-      })
-    })
-
-    afterEach(async () => {
-      sinon.restore()
-      await stop(...Object.values(components))
-      await common.teardown()
-      mockNetwork.reset()
-    })
-
-    it('is a PubSub implementation', () => {
-      expect(isPubSub(pubsub)).to.be.true()
-    })
-
-    it('can start correctly', async () => {
-      if (!isStartable(pubsub)) {
-        return
-      }
-
-      sinon.spy(components.registrar, 'register')
-
-      await start(...Object.values(components))
-
-      expect(components.registrar.register).to.have.property('callCount', 1)
-    })
-
-    it('can stop correctly', async () => {
-      if (!isStartable(pubsub)) {
-        return
-      }
-
-      sinon.spy(components.registrar, 'unregister')
-
-      await start(...Object.values(components))
-      await stop(...Object.values(components))
-
-      expect(components.registrar.unregister).to.have.property('callCount', 1)
-    })
-
-    it('can subscribe and unsubscribe correctly', async () => {
-      const handler = (): void => {
-        throw new Error('a message should not be received')
-      }
-
-      await start(...Object.values(components))
-      pubsub.subscribe(topic)
-      pubsub.addEventListener('message', handler)
-
-      await pWaitFor(() => {
-        const topics = pubsub.getTopics()
-        return topics.length === 1 && topics[0] === topic
-      })
-
-      pubsub.removeEventListener('message', handler)
-      pubsub.unsubscribe(topic)
-
-      await pWaitFor(() => pubsub.getTopics().length === 0)
-
-      // Publish to guarantee the handler is not called
-      await pubsub.publish(topic, data)
-
-      // handlers are called async
-      await delay(100)
-
-      await stop(...Object.values(components))
-    })
-
-    it('can subscribe and publish correctly', async () => {
-      const defer = pDefer()
-
-      await start(...Object.values(components))
-
-      pubsub.subscribe(topic)
-      pubsub.addEventListener('message', (evt) => {
-        expect(evt).to.have.nested.property('detail.topic', topic)
-        expect(evt).to.have.deep.nested.property('detail.data', data)
-        defer.resolve()
-      })
-      await pubsub.publish(topic, data)
-      await defer.promise
-
-      await stop(...Object.values(components))
-    })
-  })
-}