@libp2p/interface-compliance-tests 3.0.7-d853d124 → 3.0.7-e9cafd3d

package/src/mocks/peer-discovery.ts

@@ -0,0 +1,60 @@
+import { EventEmitter } from '@libp2p/interface/events'
+import { peerDiscovery } from '@libp2p/interface/peer-discovery'
+import * as PeerIdFactory from '@libp2p/peer-id-factory'
+import { multiaddr } from '@multiformats/multiaddr'
+import type { PeerDiscovery, PeerDiscoveryEvents } from '@libp2p/interface/peer-discovery'
+import type { PeerInfo } from '@libp2p/interface/peer-info'
+
+interface MockDiscoveryInit {
+  discoveryDelay?: number
+}
+
+/**
+ * Emits 'peer' events on discovery.
+ */
+export class MockDiscovery extends EventEmitter<PeerDiscoveryEvents> implements PeerDiscovery {
+  public readonly options: MockDiscoveryInit
+  private _isRunning: boolean
+  private _timer: any
+
+  constructor (init = {}) {
+    super()
+
+    this.options = init
+    this._isRunning = false
+  }
+
+  readonly [peerDiscovery] = this
+
+  start (): void {
+    this._isRunning = true
+    this._discoverPeer()
+  }
+
+  stop (): void {
+    clearTimeout(this._timer)
+    this._isRunning = false
+  }
+
+  isStarted (): boolean {
+    return this._isRunning
+  }
+
+  _discoverPeer (): void {
+    if (!this._isRunning) return
+
+    PeerIdFactory.createEd25519PeerId()
+      .then(peerId => {
+        this._timer = setTimeout(() => {
+          this.safeDispatchEvent<PeerInfo>('peer', {
+            detail: {
+              id: peerId,
+              multiaddrs: [multiaddr('/ip4/127.0.0.1/tcp/8000')],
+              protocols: []
+            }
+          })
+        }, this.options.discoveryDelay ?? 1000)
+      })
+      .catch(() => {})
+  }
+}

package/src/mocks/registrar.ts

@@ -0,0 +1,88 @@
+import merge from 'merge-options'
+import type { Connection } from '@libp2p/interface/connection'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { Topology } from '@libp2p/interface/topology'
+import type { IncomingStreamData, Registrar, StreamHandler, StreamHandlerOptions, StreamHandlerRecord } from '@libp2p/interface-internal/registrar'
+
+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 = merge.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

@@ -0,0 +1,49 @@
+import { mockConnection } from './connection.js'
+import type { Libp2pEvents } from '@libp2p/interface'
+import type { Connection, MultiaddrConnection } from '@libp2p/interface/connection'
+import type { EventEmitter } from '@libp2p/interface/events'
+import type { Registrar } from '@libp2p/interface-internal/registrar'
+import type { Upgrader, UpgraderOptions } from '@libp2p/interface-internal/upgrader'
+
+export interface MockUpgraderInit {
+  registrar?: Registrar
+  events?: EventEmitter<Libp2pEvents>
+}
+
+class MockUpgrader implements Upgrader {
+  private readonly registrar?: Registrar
+  private readonly events?: EventEmitter<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<Connection> {
+    const connection = mockConnection(multiaddrConnection, {
+      direction: 'inbound',
+      registrar: this.registrar,
+      ...opts
+    })
+
+    this.events?.safeDispatchEvent('connection:open', { detail: connection })
+
+    return connection
+  }
+}
+
+export function mockUpgrader (init: MockUpgraderInit = {}): Upgrader {
+  return new MockUpgrader(init)
+}

package/src/peer-discovery/index.ts

@@ -0,0 +1,90 @@
+import { start, stop } from '@libp2p/interface/startable'
+import { isMultiaddr } from '@multiformats/multiaddr'
+import { expect } from 'aegir/chai'
+import delay from 'delay'
+import pDefer from 'p-defer'
+import type { TestSetup } from '../index.js'
+import type { PeerDiscovery } from '@libp2p/interface/peer-discovery'
+
+export default (common: TestSetup<PeerDiscovery>): void => {
+  describe('interface-peer-discovery compliance tests', () => {
+    let discovery: PeerDiscovery
+
+    beforeEach(async () => {
+      discovery = await common.setup()
+    })
+
+    afterEach('ensure discovery was stopped', async () => {
+      await stop(discovery)
+
+      await common.teardown()
+    })
+
+    it('can start the service', async () => {
+      await start(discovery)
+    })
+
+    it('can start and stop the service', async () => {
+      await start(discovery)
+      await stop(discovery)
+    })
+
+    it('should not fail to stop the service if it was not started', async () => {
+      await stop(discovery)
+    })
+
+    it('should not fail to start the service if it is already started', async () => {
+      await start(discovery)
+      await start(discovery)
+    })
+
+    it('should emit a peer event after start', async () => {
+      const defer = pDefer()
+
+      discovery.addEventListener('peer', (evt) => {
+        const { id, multiaddrs } = evt.detail
+        expect(id).to.exist()
+        expect(id)
+          .to.have.property('type')
+          .that.is.oneOf(['RSA', 'Ed25519', 'secp256k1'])
+        expect(multiaddrs).to.exist()
+
+        multiaddrs.forEach((m) => expect(isMultiaddr(m)).to.eql(true))
+
+        defer.resolve()
+      })
+
+      await start(discovery)
+
+      await defer.promise
+    })
+
+    it('should not receive a peer event before start', async () => {
+      discovery.addEventListener('peer', () => {
+        throw new Error('should not receive a peer event before start')
+      })
+
+      await delay(2000)
+    })
+
+    it('should not receive a peer event after stop', async () => {
+      const deferStart = pDefer()
+
+      discovery.addEventListener('peer', () => {
+        deferStart.resolve()
+      })
+
+      await start(discovery)
+
+      await deferStart.promise
+
+      await stop(discovery)
+
+      discovery.addEventListener('peer', () => {
+        throw new Error('should not receive a peer event after stop')
+      })
+
+      await delay(2000)
+    })
+  })
+}

package/src/pubsub/api.ts

@@ -0,0 +1,114 @@
+import { isStartable, start, stop } from '@libp2p/interface/startable'
+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/pubsub'
+
+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('can start correctly', async () => {
+      if (!isStartable(pubsub)) {
+        return
+      }
+
+      sinon.spy(components.registrar, 'register')
+
+      await start(...Object.values(components))
+
+      expect(pubsub.isStarted()).to.equal(true)
+      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(pubsub.isStarted()).to.equal(false)
+      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))
+    })
+  })
+}