@libp2p/interface-compliance-tests 1.0.8 → 1.1.3

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,35 @@
+import type { Registrar, StreamHandler } from '@libp2p/interfaces/registrar'
+import type { MulticodecTopology } from '../../../libp2p-topology/src/multicodec-topology'
+
+export class MockRegistrar implements Registrar {
+  public readonly topologies: Map<string, MulticodecTopology> = new Map()
+  public readonly streamHandlers: Map<string, StreamHandler> = new Map()
+
+  async handle (multicodecs: string | string[], handler: StreamHandler) {
+    if (!Array.isArray(multicodecs)) {
+      multicodecs = [multicodecs]
+    }
+
+    this.streamHandlers.set(multicodecs[0], handler)
+  }
+
+  async unhandle (multicodec: string) {
+    this.streamHandlers.delete(multicodec)
+  }
+
+  register (topology: MulticodecTopology) {
+    const { multicodecs } = topology
+
+    this.topologies.set(multicodecs[0], topology)
+
+    return multicodecs[0]
+  }
+
+  unregister (id: string) {
+    this.topologies.delete(id)
+  }
+}
+
+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
+}