@libp2p/interface-compliance-tests 1.0.6 → 1.1.1

package/src/utils/mock-connection-manager.ts

@@ -0,0 +1,30 @@
+import { EventEmitter } from '@libp2p/interfaces'
+import type { Connection } from '@libp2p/interfaces/src/connection'
+import type { PeerId } from '@libp2p/interfaces/src/peer-id'
+import type { ConnectionManager, ConnectionManagerEvents } from '@libp2p/interfaces/src/registrar'
+
+class MockConnectionManager extends EventEmitter<ConnectionManagerEvents> implements ConnectionManager {
+  getConnection (peerId: PeerId): Connection | undefined {
+    throw new Error('Method not implemented.')
+  }
+
+  listenerCount (type: string): number {
+    throw new Error('Method not implemented.')
+  }
+
+  addEventListener<U extends 'peer:connect'>(type: U, callback: ((evt: ConnectionManagerEvents[U]) => void) | { handleEvent: (evt: ConnectionManagerEvents[U]) => void } | null, options?: boolean | AddEventListenerOptions): void {
+    throw new Error('Method not implemented.')
+  }
+
+  removeEventListener<U extends 'peer:connect'>(type: U, callback: (((evt: ConnectionManagerEvents[U]) => void) | { handleEvent: (evt: ConnectionManagerEvents[U]) => void } | null) | undefined, options?: boolean | EventListenerOptions): void {
+    throw new Error('Method not implemented.')
+  }
+
+  dispatchEvent (event: Event): boolean {
+    throw new Error('Method not implemented.')
+  }
+}
+
+export function mockConnectionManager () {
+  return new MockConnectionManager()
+}

package/src/utils/mock-connection.ts

@@ -0,0 +1,66 @@
+import { PeerId } from '@libp2p/peer-id'
+import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+import { pipe } from 'it-pipe'
+import type { MultiaddrConnection } from '@libp2p/interfaces/transport'
+import type { Connection, Stream, Metadata, ProtocolStream } from '@libp2p/interfaces/connection'
+import type { Muxer } from '@libp2p/interfaces/stream-muxer'
+
+export async function mockConnection (maConn: MultiaddrConnection, direction: 'inbound' | 'outbound', muxer: Muxer): Promise<Connection> {
+  const remoteAddr = maConn.remoteAddr
+  const remotePeerIdStr = remoteAddr.getPeerId()
+  const remotePeer = remotePeerIdStr != null ? PeerId.fromString(remotePeerIdStr) : await createEd25519PeerId()
+
+  const streams: Stream[] = []
+  let streamId = 0
+
+  const registry = new Map()
+
+  void pipe(
+    maConn, muxer, maConn
+  )
+
+  return {
+    id: 'mock-connection',
+    remoteAddr,
+    remotePeer,
+    stat: {
+      status: 'OPEN',
+      direction,
+      timeline: maConn.timeline,
+      multiplexer: 'test-multiplexer',
+      encryption: 'yes-yes-very-secure'
+    },
+    registry,
+    tags: [],
+    streams,
+    newStream: async (protocols) => {
+      if (!Array.isArray(protocols)) {
+        protocols = [protocols]
+      }
+
+      if (protocols.length === 0) {
+        throw new Error('protocols must have a length')
+      }
+
+      const id = `${streamId++}`
+      const stream: Stream = muxer.newStream(id)
+      const streamData: ProtocolStream = {
+        protocol: protocols[0],
+        stream
+      }
+
+      registry.set(id, streamData)
+
+      return streamData
+    },
+    addStream: (stream: Stream, metadata: Metadata) => {
+
+    },
+    removeStream: (id: string) => {
+      registry.delete(id)
+    },
+    close: async () => {
+      await maConn.close()
+    }
+  }
+}

package/src/utils/mock-multiaddr-connection.ts

@@ -0,0 +1,18 @@
+import { Multiaddr } from '@multiformats/multiaddr'
+import type { MultiaddrConnection } from '@libp2p/interfaces/transport'
+import type { Duplex } from 'it-stream-types'
+
+export function mockMultiaddrConnection (source: Duplex<Uint8Array>): MultiaddrConnection {
+  const maConn: MultiaddrConnection = {
+    ...source,
+    async close () {
+
+    },
+    timeline: {
+      open: Date.now()
+    },
+    remoteAddr: new Multiaddr('/ip4/127.0.0.1/tcp/4001')
+  }
+
+  return maConn
+}

package/src/utils/mock-muxer.ts

@@ -0,0 +1,43 @@
+import { pair } from 'it-pair'
+import { pushable } from 'it-pushable'
+import drain from 'it-drain'
+import type { Stream } from '@libp2p/interfaces/connection'
+import type { Muxer } from '@libp2p/interfaces/stream-muxer'
+
+export function mockMuxer (): Muxer {
+  let streamId = 0
+  let streams: Stream[] = []
+  const p = pushable<Uint8Array>()
+
+  const muxer: Muxer = {
+    source: p,
+    sink: async (source) => {
+      await drain(source)
+    },
+    get streams () {
+      return streams
+    },
+    newStream: (name?: string) => {
+      const echo = pair<Uint8Array>()
+
+      const id = `${streamId++}`
+      const stream: Stream = {
+        id,
+        sink: echo.sink,
+        source: echo.source,
+        close: () => {
+          streams = streams.filter(s => s !== stream)
+        },
+        abort: () => {},
+        reset: () => {},
+        timeline: {
+          open: 0
+        }
+      }
+
+      return stream
+    }
+  }
+
+  return muxer
+}

package/src/utils/mock-registrar.ts

@@ -0,0 +1,49 @@
+import type { IncomingStreamEvent, Registrar } from '@libp2p/interfaces/registrar'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { Connection } from '@libp2p/interfaces/connection'
+
+class MockRegistrar implements Registrar {
+  private readonly registrarRecord: Map<string, Record<string, any>> = new Map()
+
+  handle (multicodecs: string | string[], handler: (event: IncomingStreamEvent) => void) {
+    if (!Array.isArray(multicodecs)) {
+      multicodecs = [multicodecs]
+    }
+
+    const rec = this.registrarRecord.get(multicodecs[0]) ?? {}
+
+    this.registrarRecord.set(multicodecs[0], {
+      ...rec,
+      handler
+    })
+  }
+
+  unhandle (multicodec: string) {
+    this.registrarRecord.delete(multicodec)
+  }
+
+  register (topology: any) {
+    const { multicodecs } = topology
+    const rec = this.registrarRecord.get(multicodecs[0]) ?? {}
+
+    this.registrarRecord.set(multicodecs[0], {
+      ...rec,
+      onConnect: topology._onConnect,
+      onDisconnect: topology._onDisconnect
+    })
+
+    return multicodecs[0]
+  }
+
+  unregister (id: string) {
+    this.registrarRecord.delete(id)
+  }
+
+  getConnection (peerId: PeerId): Connection | undefined {
+    throw new Error('Not implemented')
+  }
+}
+
+export function mockRegistrar () {
+  return new MockRegistrar()
+}

package/src/utils/mock-upgrader.ts

@@ -0,0 +1,33 @@
+import { expect } from 'aegir/utils/chai.js'
+import { mockMuxer } from './mock-muxer.js'
+import { mockConnection } from './mock-connection.js'
+import type { Upgrader, MultiaddrConnection } from '@libp2p/interfaces/transport'
+import type { Muxer } from '@libp2p/interfaces/stream-muxer'
+
+export interface MockUpgraderOptions {
+  muxer?: Muxer
+}
+
+export function mockUpgrader (options: MockUpgraderOptions = {}) {
+  const ensureProps = (multiaddrConnection: MultiaddrConnection) => {
+    ['sink', 'source', 'remoteAddr', 'timeline', 'close'].forEach(prop => {
+      expect(multiaddrConnection).to.have.property(prop)
+    })
+    return multiaddrConnection
+  }
+
+  const muxer = options.muxer ?? mockMuxer()
+
+  const upgrader: Upgrader = {
+    async upgradeOutbound (multiaddrConnection) {
+      ensureProps(multiaddrConnection)
+      return await mockConnection(multiaddrConnection, 'outbound', muxer)
+    },
+    async upgradeInbound (multiaddrConnection) {
+      ensureProps(multiaddrConnection)
+      return await mockConnection(multiaddrConnection, 'inbound', muxer)
+    }
+  }
+
+  return upgrader
+}