@libp2p/interface-compliance-tests 1.1.9 → 1.1.13

package/src/mocks/muxer.ts

@@ -2,244 +2,368 @@ 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 { Muxer, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
 import type { Source } from 'it-stream-types'
+import { pipe } from 'it-pipe'
+import map from 'it-map'
+
+let muxers = 0
+let streams = 0
 
 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
+type StreamMessage = DataMessage | ResetMessage | CloseMessage | CreateMessage
 
 class MuxedStream {
   public id: string
   public input: Pushable<Uint8Array>
   public stream: Stream
+  public type: 'initiator' | 'recipient'
 
-  private sourceClosed: boolean
-  private sinkClosed: boolean
-  private readonly controller: AbortController
-  private readonly onEnd: () => void
+  private sinkEnded: boolean
+  private sourceEnded: boolean
+  private readonly abortController: AbortController
+  private readonly resetController: AbortController
+  private readonly log: Logger
 
-  constructor (opts: { id: string, push: Pushable<StreamMessage>, onEnd: () => void }) {
-    const { id, push, onEnd } = opts
+  constructor (opts: { id: string, type: 'initiator' | 'recipient', push: Pushable<StreamMessage>, onEnd: (err?: Error) => void }) {
+    const { id, type, push, onEnd } = opts
+
+    this.log = logger(`libp2p:mock-muxer:stream:${id}:${type}`)
 
     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.type = type
+    this.abortController = new AbortController()
+    this.resetController = 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) => {
-        source = abortableSource(source, this.controller.signal)
+        source = abortableSource(source, anySignal([
+          this.abortController.signal,
+          this.resetController.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)
+          }
+
           for await (const chunk of source) {
             const dataMsg: DataMessage = {
               id,
               type: 'data',
-              chunk: uint8ArrayToString(chunk, 'base64')
+              chunk: uint8ArrayToString(chunk, 'base64'),
+              direction: this.type
             }
 
             push.push(dataMsg)
           }
+        } catch (err: any) {
+          if (err.type === 'aborted' && err.message === 'The operation was aborted') {
+            if (this.resetController.signal.aborted) {
+              err.message = 'stream reset'
+              err.code = 'ERR_STREAM_RESET'
+            }
 
-          const closeMsg: CloseMessage = {
-            id,
-            type: 'close'
+            if (this.abortController.signal.aborted) {
+              err.message = 'stream aborted'
+              err.code = 'ERR_STREAM_ABORT'
+            }
           }
 
-          push.push(closeMsg)
-        } catch (err) {
-          if (!this.controller.signal.aborted) {
-            throw err
+          // 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.closeSink()
-      },
-      source: this.input,
-      close: () => {
+        this.log('sink ended')
+
+        onSinkEnd()
+
         const closeMsg: CloseMessage = {
           id,
-          type: 'close'
+          type: 'close',
+          direction: this.type
         }
         push.push(closeMsg)
+      },
+      source: this.input,
 
-        this.closeSink()
-        this.closeSource()
+      // Close for reading
+      close: () => {
+        this.input.end()
       },
-      abort: () => {
-        const resetMsg: ResetMessage = {
-          id,
-          type: 'reset'
-        }
-        push.push(resetMsg)
 
-        this.closeSink()
-        this.closeSource()
+      // Close for reading and writing (local error)
+      abort: (err?: Error) => {
+        // End the source with the passed error
+        this.input.end()
+        this.abortController.abort()
+        onSinkEnd(err)
       },
-      reset: () => {
-        const resetMsg: ResetMessage = {
-          id,
-          type: 'reset'
-        }
-        push.push(resetMsg)
 
-        this.closeSink()
-        this.closeSource()
+      // 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()
       }
     }
   }
+}
 
-  maybeEndStream () {
-    if (this.stream.timeline.close != null) {
-      // already ended
-      return
-    }
+class MockMuxer implements Muxer {
+  public source: Source<Uint8Array>
+  public input: Pushable<Uint8Array>
+  public streamInput: Pushable<StreamMessage>
+  public name: string
+
+  private readonly registryInitiatorStreams: Map<string, MuxedStream>
+  private readonly registryRecipientStreams: Map<string, MuxedStream>
+  private readonly options: MuxerOptions
+
+  private readonly log: Logger
+
+  constructor (options?: MuxerOptions) {
+    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 = options ?? {}
+    // 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) {
+          stream.abort(err)
+        }
+      }
+    })
 
-    if (this.sinkClosed && this.sourceClosed) {
-      this.stream.timeline.close = Date.now()
-      this.onEnd()
-    }
+    // receives messages from all of the muxed streams
+    this.streamInput = pushable<StreamMessage>()
   }
 
-  closeSource () {
-    this.sourceClosed = true
-    this.input.end()
-  }
+  // 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('-> %s %s %s', message.type, message.direction, message.id)
+            this.handleMessage(message)
+          }
+        }
+      )
 
-  closeSink () {
-    this.sinkClosed = true
-    this.controller.abort()
-    this.maybeEndStream()
+      this.log('muxed stream ended')
+      this.input.end()
+    } catch (err: any) {
+      this.log('muxed stream errored', err)
+      this.input.end(err)
+    }
   }
-}
 
-export function mockMuxer (options?: MuxerOptions): Muxer {
-  let streamId = 0
-  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()
+  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}`)
       }
-    }
-  })
 
-  // 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
-        })))
+      muxedStream = this.createStream(message.id, 'recipient')
+      registry.set(muxedStream.stream.id, muxedStream)
+
+      if (this.options.onIncomingStream != null) {
+        this.options.onIncomingStream(muxedStream.stream)
       }
     }
-  })
 
-  function createStream (name?: string): MuxedStream {
-    const id = name ?? `${streamId++}`
+    muxedStream = registry.get(message.id)
 
-    const muxedStream: MuxedStream = new MuxedStream({
-      id,
-      push,
-      onEnd: () => {
-        streams.delete(id)
-
-        if (options?.onStreamEnd != null) {
-          options?.onStreamEnd(muxedStream.stream)
-        }
-      }
-    })
+    if (muxedStream == null) {
+      throw new Error(`No stream found for ${message.id}`)
+    }
 
-    return muxedStream
+    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)
+      muxedStream.stream.close()
+    }
   }
 
-  const muxer: Muxer = {
-    // 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)
+  get streams () {
+    return Array.from(this.registryRecipientStreams.values())
+      .concat(Array.from(this.registryInitiatorStreams.values()))
+      .map(({ stream }) => stream)
+  }
 
-        if (muxedStream == null) {
-          muxedStream = createStream(message.id)
-          streams.set(muxedStream.stream.id, muxedStream)
+  newStream (name?: string) {
+    this.log('newStream %s', name)
+    const storedStream = this.createStream(name, 'initiator')
+    this.registryInitiatorStreams.set(storedStream.stream.id, storedStream)
 
-          if (options?.onStream != null) {
-            options.onStream(muxedStream.stream)
-          }
-        }
+    return storedStream.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()
-        }
-      }
+  createStream (name?: string, type: 'initiator' | 'recipient' = 'initiator'): MuxedStream {
+    const id = name ?? `${this.name}:stream:${streams++}`
 
-      for (const muxedStream of streams.values()) {
-        muxedStream.stream.close()
-      }
+    this.log('createStream %s %s', type, id)
 
-      muxerSource.end()
-    },
+    const muxedStream: MuxedStream = new MuxedStream({
+      id,
+      type,
+      push: this.streamInput,
+      onEnd: () => {
+        this.log('stream ended %s %s', type, id)
 
-    source: muxerSource,
+        if (type === 'initiator') {
+          this.registryInitiatorStreams.delete(id)
+        } else {
+          this.registryRecipientStreams.delete(id)
+        }
 
-    get streams () {
-      return Array.from(streams.values()).map(({ stream }) => stream)
-    },
+        if (this.options.onStreamEnd != null) {
+          this.options.onStreamEnd(muxedStream.stream)
+        }
+      }
+    })
 
-    newStream (name?: string) {
-      const storedStream = createStream(name)
+    return muxedStream
+  }
+}
 
-      streams.set(storedStream.stream.id, storedStream)
+export function mockMuxer (options?: MuxerOptions): Muxer {
+  const mockMuxer = new MockMuxer(options)
 
-      if (options?.onStream != null) {
-        options.onStream(storedStream.stream)
+  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 storedStream.stream
-    }
-  }
-
-  return muxer
+  return mockMuxer
 }

package/src/mocks/registrar.ts

@@ -116,18 +116,20 @@ export async function mockIncomingStreamEvent (protocol: string, conn: Connectio
   })
 }
 
-export async function connectPeers (protocol: string, registrarA: Registrar, registrarB: Registrar, peerIdA: PeerId, peerIdB: PeerId) {
-  const topologyA = registrarA.getTopologies(protocol)[0]
-  const topologyB = registrarB.getTopologies(protocol)[0]
-  // const handlerA = registrarA.getHandler(protocol)
-  // const handlerB = registrarB.getHandler(protocol)
+export interface Peer {
+  peerId: PeerId
+  registrar: Registrar
+}
 
+export async function connectPeers (protocol: string, a: Peer, b: Peer) {
   // Notify peers of connection
-  const [bToA, aToB] = connectionPair(peerIdA, peerIdB)
+  const [aToB, bToA] = connectionPair(a, b)
 
-  await topologyA.onConnect(peerIdB, aToB)
-  // await handlerA(await mockIncomingStreamEvent(protocol, aToB, peerIdB))
+  for (const topology of a.registrar.getTopologies(protocol)) {
+    await topology.onConnect(b.peerId, aToB)
+  }
 
-  await topologyB.onConnect(peerIdA, bToA)
-  // await handlerB(await mockIncomingStreamEvent(protocol, bToA, peerIdA))
+  for (const topology of b.registrar.getTopologies(protocol)) {
+    await topology.onConnect(a.peerId, bToA)
+  }
 }

package/src/mocks/upgrader.ts

@@ -1,10 +1,10 @@
 import { expect } from 'aegir/utils/chai.js'
 import { mockConnection } from './connection.js'
 import type { Upgrader, MultiaddrConnection } from '@libp2p/interfaces/transport'
-import type { Muxer } from '@libp2p/interfaces/stream-muxer'
+import type { Registrar } from '@libp2p/interfaces/registrar'
 
 export interface MockUpgraderOptions {
-  muxer?: Muxer
+  registrar?: Registrar
 }
 
 export function mockUpgrader (options: MockUpgraderOptions = {}) {
@@ -20,14 +20,14 @@ export function mockUpgrader (options: MockUpgraderOptions = {}) {
       ensureProps(multiaddrConnection)
       return mockConnection(multiaddrConnection, {
         direction: 'outbound',
-        muxer: options.muxer
+        registrar: options.registrar
       })
     },
     async upgradeInbound (multiaddrConnection) {
       ensureProps(multiaddrConnection)
       return mockConnection(multiaddrConnection, {
         direction: 'inbound',
-        muxer: options.muxer
+        registrar: options.registrar
       })
     }
   }

package/src/pubsub/api.ts

@@ -3,17 +3,20 @@ import sinon from 'sinon'
 import pDefer from 'p-defer'
 import pWaitFor from 'p-wait-for'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { mockRegistrar } from '../mocks/registrar.js'
+import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+import delay from 'delay'
+import { CustomEvent } from '@libp2p/interfaces'
 import type { TestSetup } from '../index.js'
 import type { PubSub, PubSubOptions } from '@libp2p/interfaces/pubsub'
 import type { EventMap } from './index.js'
 import type { Registrar } from '@libp2p/interfaces/src/registrar'
-import { mockRegistrar } from '../mocks/registrar.js'
-import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+import type { PubsubBaseProtocol } from '@libp2p/pubsub'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
 
-export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
+export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>) => {
   describe('pubsub api', () => {
     let pubsub: PubSub<EventMap>
     let registrar: Registrar
@@ -60,20 +63,22 @@ export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
       }
 
       await pubsub.start()
-      pubsub.subscribe(topic)
-      pubsub.addEventListener('topic', handler)
+      pubsub.addEventListener(topic, handler)
 
       await pWaitFor(() => {
         const topics = pubsub.getTopics()
         return topics.length === 1 && topics[0] === topic
       })
 
-      pubsub.unsubscribe(topic)
+      pubsub.removeEventListener(topic, handler)
 
       await pWaitFor(() => pubsub.getTopics().length === 0)
 
       // Publish to guarantee the handler is not called
-      await pubsub.publish(topic, data)
+      pubsub.dispatchEvent(new CustomEvent(topic, { detail: data }))
+
+      // handlers are called async
+      await delay(100)
 
       await pubsub.stop()
     })
@@ -83,13 +88,12 @@ export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
 
       await pubsub.start()
 
-      pubsub.subscribe(topic)
       pubsub.addEventListener(topic, (evt) => {
         const msg = evt.detail
         expect(msg).to.not.eql(undefined)
         defer.resolve()
       })
-      await pubsub.publish(topic, data)
+      pubsub.dispatchEvent(new CustomEvent(topic, { detail: data }))
       await defer.promise
 
       await pubsub.stop()