@libp2p/interface-compliance-tests 1.1.6 → 1.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/interface-compliance-tests",
-  "version": "1.1.6",
+  "version": "1.1.10",
   "description": "Compliance tests for JS libp2p interfaces",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p-interfaces/tree/master/packages/libp2p-interface-compliance-tests#readme",
@@ -56,6 +56,10 @@
       "import": "./dist/src/crypto/index.js",
       "types": "./dist/src/crypto/index.d.ts"
     },
+    "./mocks": {
+      "import": "./dist/src/mocks/index.js",
+      "types": "./dist/src/mocks/index.d.ts"
+    },
     "./peer-discovery": {
       "import": "./dist/src/peer-discovery/index.js",
       "types": "./dist/src/peer-discovery/index.d.ts"
@@ -88,10 +92,6 @@
       "import": "./dist/src/transport/utils/index.js",
       "types": "./dist/src/transport/utils/index.d.ts"
     },
-    "./mocks": {
-      "import": "./dist/src/mocks/index.js",
-      "types": "./dist/src/mocks/index.d.ts"
-    },
     "./utils/peers": {
       "import": "./dist/src/utils/peers.js",
       "types": "./dist/src/utils/peers.d.ts"
@@ -200,6 +200,8 @@
   "dependencies": {
     "@libp2p/crypto": "^0.22.2",
     "@libp2p/interfaces": "^1.0.0",
+    "@libp2p/logger": "^1.0.3",
+    "@libp2p/multistream-select": "^1.0.0",
     "@libp2p/peer-id": "^1.0.0",
     "@libp2p/peer-id-factory": "^1.0.0",
     "@libp2p/pubsub": "^1.1.0",

package/src/mocks/connection.ts

@@ -1,5 +1,4 @@
 import { peerIdFromString } from '@libp2p/peer-id'
-import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 import { pipe } from 'it-pipe'
 import { duplexPair } from 'it-pair/duplex'
 import type { MultiaddrConnection } from '@libp2p/interfaces/transport'
@@ -7,20 +6,68 @@ import type { Connection, Stream, Metadata, ProtocolStream } from '@libp2p/inter
 import type { Muxer } from '@libp2p/interfaces/stream-muxer'
 import type { Duplex } from 'it-stream-types'
 import { mockMuxer } from './muxer.js'
+import type { PeerId } from '@libp2p/interfaces/src/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 { CustomEvent } from '@libp2p/interfaces'
 
-export async function mockConnection (maConn: MultiaddrConnection, direction: 'inbound' | 'outbound' = 'inbound', muxer: Muxer = mockMuxer()): Promise<Connection> {
+const log = logger('libp2p:mock-connection')
+
+export interface MockConnectionOptions {
+  direction?: 'inbound' | 'outbound'
+  muxer?: Muxer
+  registrar?: Registrar
+}
+
+export function mockConnection (maConn: MultiaddrConnection, opts: MockConnectionOptions = {}): Connection {
   const remoteAddr = maConn.remoteAddr
   const remotePeerIdStr = remoteAddr.getPeerId()
-  const remotePeer = remotePeerIdStr != null ? peerIdFromString(remotePeerIdStr) : await createEd25519PeerId()
+
+  if (remotePeerIdStr == null) {
+    throw new Error('Remote multiaddr must contain a peer id')
+  }
+
+  const remotePeer = peerIdFromString(remotePeerIdStr)
   const registry = new Map()
   const streams: Stream[] = []
-  let streamId = 0
+  const direction = opts.direction ?? 'inbound'
+  const registrar = opts.registrar ?? mockRegistrar()
+
+  const muxer = opts.muxer ?? mockMuxer({
+    onStream: (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(new CustomEvent('incomingStream', {
+              detail: { connection, stream: muxedStream, protocol }
+            }))
+          }).catch(err => {
+            log.error(err)
+          })
+      } catch (err: any) {
+        log.error(err)
+      }
+    },
+    onStreamEnd: (stream) => {
+      connection.removeStream(stream.id)
+    }
+  })
 
   void pipe(
     maConn, muxer, maConn
   )
 
-  return {
+  const connection: Connection = {
     id: 'mock-connection',
     remoteAddr,
     remotePeer,
@@ -43,11 +90,17 @@ export async function mockConnection (maConn: MultiaddrConnection, direction: 'i
         throw new Error('protocols must have a length')
       }
 
-      const id = `${streamId++}`
+      const id = `${Math.random()}`
       const stream: Stream = muxer.newStream(id)
+      const mss = new Dialer(stream)
+      const result = await mss.select(protocols)
+
       const streamData: ProtocolStream = {
-        protocol: protocols[0],
-        stream
+        protocol: result.protocol,
+        stream: {
+          ...stream,
+          ...result.stream
+        }
       }
 
       registry.set(id, streamData)
@@ -64,6 +117,8 @@ export async function mockConnection (maConn: MultiaddrConnection, direction: 'i
       await maConn.close()
     }
   }
+
+  return connection
 }
 
 export function mockStream (stream: Duplex<Uint8Array>): Stream {
@@ -79,23 +134,24 @@ export function mockStream (stream: Duplex<Uint8Array>): Stream {
   }
 }
 
-export function connectionPair (): [ Connection, Connection ] {
-  const [d0, d1] = duplexPair<Uint8Array>()
+export interface Peer {
+  peerId: PeerId
+  registrar: Registrar
+}
+
+export function connectionPair (a: Peer, b: Peer): [ Connection, Connection ] {
+  const [peerBtoPeerA, peerAtoPeerB] = duplexPair<Uint8Array>()
 
   return [
-    // @ts-expect-error not a complete implementation
-    {
-      newStream: async (multicodecs: string[]) => await Promise.resolve({
-        stream: mockStream(d0),
-        protocol: multicodecs[0]
-      })
-    },
-    // @ts-expect-error not a complete implementation
-    {
-      newStream: async (multicodecs: string[]) => await Promise.resolve({
-        stream: mockStream(d1),
-        protocol: multicodecs[0]
-      })
-    }
+    mockConnection(
+      mockMultiaddrConnection(peerAtoPeerB, b.peerId), {
+        registrar: a.registrar
+      }
+    ),
+    mockConnection(
+      mockMultiaddrConnection(peerBtoPeerA, a.peerId), {
+        registrar: b.registrar
+      }
+    )
   ]
 }

package/src/mocks/multiaddr-connection.ts

@@ -1,8 +1,9 @@
 import { Multiaddr } from '@multiformats/multiaddr'
 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>): MultiaddrConnection {
+export function mockMultiaddrConnection (source: Duplex<Uint8Array> & Partial<MultiaddrConnection>, peerId: PeerId): MultiaddrConnection {
   const maConn: MultiaddrConnection = {
     async close () {
 
@@ -10,7 +11,7 @@ export function mockMultiaddrConnection (source: Duplex<Uint8Array> & Partial<Mu
     timeline: {
       open: Date.now()
     },
-    remoteAddr: new Multiaddr('/ip4/127.0.0.1/tcp/4001'),
+    remoteAddr: new Multiaddr(`/ip4/127.0.0.1/tcp/4001/p2p/${peerId.toString()}`),
     ...source
   }
 

package/src/mocks/muxer.ts

@@ -1,41 +1,243 @@
-import { pair } from 'it-pair'
-import { pushable } from 'it-pushable'
-import drain from 'it-drain'
+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 type { Stream } from '@libp2p/interfaces/connection'
-import type { Muxer } from '@libp2p/interfaces/stream-muxer'
+import type { Muxer, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
+import type { Source } from 'it-stream-types'
 
-export function mockMuxer (): Muxer {
+interface DataMessage {
+  id: string
+  type: 'data'
+  chunk: string
+}
+
+interface ResetMessage {
+  id: string
+  type: 'reset'
+}
+
+interface CloseMessage {
+  id: string
+  type: 'close'
+}
+
+type StreamMessage = DataMessage | ResetMessage | CloseMessage
+
+class MuxedStream {
+  public id: string
+  public input: Pushable<Uint8Array>
+  public stream: Stream
+
+  private sourceClosed: boolean
+  private sinkClosed: boolean
+  private readonly controller: AbortController
+  private readonly onEnd: () => void
+
+  constructor (opts: { id: string, push: Pushable<StreamMessage>, onEnd: () => void }) {
+    const { id, push, onEnd } = opts
+
+    this.id = id
+    this.controller = new AbortController()
+    this.onEnd = onEnd
+    this.sourceClosed = false
+    this.sinkClosed = false
+    this.input = pushable<Uint8Array>({
+      onEnd: () => {
+        this.sourceClosed = true
+        this.maybeEndStream()
+      }
+    })
+    this.stream = {
+      id,
+      sink: async (source) => {
+        source = abortableSource(source, this.controller.signal)
+
+        try {
+          for await (const chunk of source) {
+            const dataMsg: DataMessage = {
+              id,
+              type: 'data',
+              chunk: uint8ArrayToString(chunk, 'base64')
+            }
+
+            push.push(dataMsg)
+          }
+
+          const closeMsg: CloseMessage = {
+            id,
+            type: 'close'
+          }
+
+          push.push(closeMsg)
+        } catch (err) {
+          if (!this.controller.signal.aborted) {
+            throw err
+          }
+        }
+
+        this.closeSink()
+      },
+      source: this.input,
+      close: () => {
+        const closeMsg: CloseMessage = {
+          id,
+          type: 'close'
+        }
+        push.push(closeMsg)
+
+        this.closeSink()
+        this.closeSource()
+      },
+      abort: () => {
+        const resetMsg: ResetMessage = {
+          id,
+          type: 'reset'
+        }
+        push.push(resetMsg)
+
+        this.closeSink()
+        this.closeSource()
+      },
+      reset: () => {
+        const resetMsg: ResetMessage = {
+          id,
+          type: 'reset'
+        }
+        push.push(resetMsg)
+
+        this.closeSink()
+        this.closeSource()
+      },
+      timeline: {
+        open: Date.now()
+      }
+    }
+  }
+
+  maybeEndStream () {
+    if (this.stream.timeline.close != null) {
+      // already ended
+      return
+    }
+
+    if (this.sinkClosed && this.sourceClosed) {
+      this.stream.timeline.close = Date.now()
+      this.onEnd()
+    }
+  }
+
+  closeSource () {
+    this.sourceClosed = true
+    this.input.end()
+  }
+
+  closeSink () {
+    this.sinkClosed = true
+    this.controller.abort()
+    this.maybeEndStream()
+  }
+}
+
+export function mockMuxer (options?: MuxerOptions): Muxer {
   let streamId = 0
-  let streams: Stream[] = []
-  const p = pushable<Uint8Array>()
+  const streams = new Map<string, MuxedStream>()
+
+  // process incoming messages from the other muxer
+  const muxerSource = pushable<Uint8Array>({
+    onEnd: () => {
+      for (const muxedStream of streams.values()) {
+        muxedStream.stream.close()
+      }
+    }
+  })
+
+  // receives messages from all of the muxed streams
+  const push = pushable<StreamMessage>()
+  void Promise.resolve().then(async () => {
+    for await (const message of push) {
+      if (message.type === 'data') {
+        muxerSource.push(uint8ArrayFromString(JSON.stringify({
+          id: message.id,
+          type: message.type,
+          chunk: message.chunk
+        })))
+      } else {
+        muxerSource.push(uint8ArrayFromString(JSON.stringify({
+          id: message.id,
+          type: message.type
+        })))
+      }
+    }
+  })
+
+  function createStream (name?: string): MuxedStream {
+    const id = name ?? `${streamId++}`
+
+    const muxedStream: MuxedStream = new MuxedStream({
+      id,
+      push,
+      onEnd: () => {
+        streams.delete(id)
+
+        if (options?.onStreamEnd != null) {
+          options?.onStreamEnd(muxedStream.stream)
+        }
+      }
+    })
+
+    return muxedStream
+  }
 
   const muxer: Muxer = {
-    source: p,
-    sink: async (source) => {
-      await drain(source)
+    // receive incoming messages
+    async sink (source: Source<Uint8Array>) {
+      for await (const buf of source) {
+        const message: StreamMessage = JSON.parse(uint8ArrayToString(buf))
+        let muxedStream = streams.get(message.id)
+
+        if (muxedStream == null) {
+          muxedStream = createStream(message.id)
+          streams.set(muxedStream.stream.id, muxedStream)
+
+          if (options?.onStream != null) {
+            options.onStream(muxedStream.stream)
+          }
+        }
+
+        if (message.type === 'data') {
+          muxedStream.input.push(uint8ArrayFromString(message.chunk, 'base64'))
+        } else if (message.type === 'reset') {
+          muxedStream.closeSink()
+          muxedStream.closeSource()
+        } else if (message.type === 'close') {
+          muxedStream.closeSource()
+        }
+      }
+
+      for (const muxedStream of streams.values()) {
+        muxedStream.stream.close()
+      }
+
+      muxerSource.end()
     },
+
+    source: muxerSource,
+
     get streams () {
-      return streams
+      return Array.from(streams.values()).map(({ stream }) => stream)
     },
-    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
-        }
+
+    newStream (name?: string) {
+      const storedStream = createStream(name)
+
+      streams.set(storedStream.stream.id, storedStream)
+
+      if (options?.onStream != null) {
+        options.onStream(storedStream.stream)
       }
 
-      return stream
+      return storedStream.stream
     }
   }
 

package/src/mocks/registrar.ts

@@ -1,15 +1,41 @@
-import type { Registrar, StreamHandler } from '@libp2p/interfaces/registrar'
+import type { IncomingStreamData, Registrar, StreamHandler } from '@libp2p/interfaces/registrar'
+import type { Connection } from '@libp2p/interfaces/src/connection'
+import type { PeerId } from '@libp2p/interfaces/src/peer-id'
 import type { Topology } from '@libp2p/interfaces/topology'
+import { connectionPair } from './connection.js'
+import { CustomEvent } from '@libp2p/interfaces'
 
 export class MockRegistrar implements Registrar {
   private readonly topologies: Map<string, { topology: Topology, protocols: string[] }> = new Map()
   private readonly handlers: Map<string, { handler: StreamHandler, protocols: string[] }> = new Map()
 
+  getProtocols () {
+    const protocols = new Set<string>()
+
+    for (const topology of this.topologies.values()) {
+      topology.protocols.forEach(protocol => protocols.add(protocol))
+    }
+
+    for (const handler of this.handlers.values()) {
+      handler.protocols.forEach(protocol => protocols.add(protocol))
+    }
+
+    return Array.from(protocols).sort()
+  }
+
   async handle (protocols: string | string[], handler: StreamHandler) {
     if (!Array.isArray(protocols)) {
       protocols = [protocols]
     }
 
+    for (const protocol of protocols) {
+      for (const { protocols } of this.handlers.values()) {
+        if (protocols.includes(protocol)) {
+          throw new Error(`Handler already registered for protocol ${protocol}`)
+        }
+      }
+    }
+
     const id = `handler-id-${Math.random()}`
 
     this.handlers.set(id, {
@@ -24,16 +50,14 @@ export class MockRegistrar implements Registrar {
     this.handlers.delete(id)
   }
 
-  getHandlers (protocol: string) {
-    const output: StreamHandler[] = []
-
+  getHandler (protocol: string) {
     for (const { handler, protocols } of this.handlers.values()) {
       if (protocols.includes(protocol)) {
-        output.push(handler)
+        return handler
       }
     }
 
-    return output
+    throw new Error(`No handler registered for protocol ${protocol}`)
   }
 
   register (protocols: string | string[], topology: Topology) {
@@ -68,10 +92,44 @@ export class MockRegistrar implements Registrar {
       }
     }
 
-    return output
+    if (output.length > 0) {
+      return output
+    }
+
+    throw new Error(`No topologies registered for protocol ${protocol}`)
   }
 }
 
 export function mockRegistrar () {
   return new MockRegistrar()
 }
+
+export async function mockIncomingStreamEvent (protocol: string, conn: Connection, remotePeer: PeerId): Promise<CustomEvent<IncomingStreamData>> {
+  // @ts-expect-error incomplete implementation
+  return new CustomEvent('incomingStream', {
+    detail: {
+      ...await conn.newStream([protocol]),
+      connection: {
+        remotePeer
+      }
+    }
+  })
+}
+
+export interface Peer {
+  peerId: PeerId
+  registrar: Registrar
+}
+
+export async function connectPeers (protocol: string, a: Peer, b: Peer) {
+  // Notify peers of connection
+  const [aToB, bToA] = connectionPair(a, b)
+
+  for (const topology of a.registrar.getTopologies(protocol)) {
+    await topology.onConnect(b.peerId, aToB)
+  }
+
+  for (const topology of b.registrar.getTopologies(protocol)) {
+    await topology.onConnect(a.peerId, bToA)
+  }
+}

package/src/mocks/upgrader.ts

@@ -1,5 +1,4 @@
 import { expect } from 'aegir/utils/chai.js'
-import { mockMuxer } from './muxer.js'
 import { mockConnection } from './connection.js'
 import type { Upgrader, MultiaddrConnection } from '@libp2p/interfaces/transport'
 import type { Muxer } from '@libp2p/interfaces/stream-muxer'
@@ -16,16 +15,20 @@ export function mockUpgrader (options: MockUpgraderOptions = {}) {
     return multiaddrConnection
   }
 
-  const muxer = options.muxer ?? mockMuxer()
-
   const upgrader: Upgrader = {
     async upgradeOutbound (multiaddrConnection) {
       ensureProps(multiaddrConnection)
-      return await mockConnection(multiaddrConnection, 'outbound', muxer)
+      return mockConnection(multiaddrConnection, {
+        direction: 'outbound',
+        muxer: options.muxer
+      })
     },
     async upgradeInbound (multiaddrConnection) {
       ensureProps(multiaddrConnection)
-      return await mockConnection(multiaddrConnection, 'inbound', muxer)
+      return mockConnection(multiaddrConnection, {
+        direction: 'inbound',
+        muxer: options.muxer
+      })
     }
   }