@libp2p/interface-compliance-tests 2.0.2 → 3.0.1

package/src/mocks/registrar.ts

@@ -1,96 +0,0 @@
-import type { IncomingStreamData, Registrar, StreamHandler } from '@libp2p/interfaces/registrar'
-import type { Connection } from '@libp2p/interfaces/connection'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
-import type { Topology } from '@libp2p/interfaces/topology'
-
-export class MockRegistrar implements Registrar {
-  private readonly topologies: Map<string, { topology: Topology, protocols: string[] }> = new Map()
-  private readonly handlers: Map<string, StreamHandler> = new Map()
-
-  getProtocols () {
-    return Array.from(this.handlers.keys()).sort()
-  }
-
-  async handle (protocols: string | string[], handler: StreamHandler): Promise<void> {
-    const protocolList = Array.isArray(protocols) ? protocols : [protocols]
-
-    for (const protocol of protocolList) {
-      if (this.handlers.has(protocol)) {
-        throw new Error(`Handler already registered for protocol ${protocol}`)
-      }
-
-      this.handlers.set(protocol, handler)
-    }
-  }
-
-  async unhandle (protocols: string | string[]) {
-    const protocolList = Array.isArray(protocols) ? protocols : [protocols]
-
-    protocolList.forEach(protocol => {
-      this.handlers.delete(protocol)
-    })
-  }
-
-  getHandler (protocol: string) {
-    const handler = this.handlers.get(protocol)
-
-    if (handler == null) {
-      throw new Error(`No handler registered for protocol ${protocol}`)
-    }
-
-    return handler
-  }
-
-  async register (protocols: string | string[], topology: Topology) {
-    if (!Array.isArray(protocols)) {
-      protocols = [protocols]
-    }
-
-    const id = `topology-id-${Math.random()}`
-
-    this.topologies.set(id, {
-      topology,
-      protocols
-    })
-
-    return id
-  }
-
-  unregister (id: string | string[]) {
-    if (!Array.isArray(id)) {
-      id = [id]
-    }
-
-    id.forEach(id => this.topologies.delete(id))
-  }
-
-  getTopologies (protocol: string) {
-    const output: Topology[] = []
-
-    for (const { topology, protocols } of this.topologies.values()) {
-      if (protocols.includes(protocol)) {
-        output.push(topology)
-      }
-    }
-
-    if (output.length > 0) {
-      return output
-    }
-
-    return []
-  }
-}
-
-export function mockRegistrar () {
-  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

@@ -1,46 +0,0 @@
-import { expect } from 'aegir/chai'
-import { mockConnection } from './connection.js'
-import type { Upgrader, MultiaddrConnection, UpgraderEvents } from '@libp2p/interfaces/transport'
-import type { Registrar } from '@libp2p/interfaces/registrar'
-import { EventEmitter } from '@libp2p/interfaces/events'
-
-export interface MockUpgraderInit {
-  registrar?: Registrar
-}
-
-function ensureProps (multiaddrConnection: MultiaddrConnection) {
-  ['sink', 'source', 'remoteAddr', 'timeline', 'close'].forEach(prop => {
-    expect(multiaddrConnection).to.have.property(prop)
-  })
-  return multiaddrConnection
-}
-
-class MockUpgrader extends EventEmitter<UpgraderEvents> implements Upgrader {
-  private readonly registrar?: Registrar
-
-  constructor (init: MockUpgraderInit = {}) {
-    super()
-
-    this.registrar = init.registrar
-  }
-
-  async upgradeOutbound (multiaddrConnection: MultiaddrConnection) {
-    ensureProps(multiaddrConnection)
-    return mockConnection(multiaddrConnection, {
-      direction: 'outbound',
-      registrar: this.registrar
-    })
-  }
-
-  async upgradeInbound (multiaddrConnection: MultiaddrConnection) {
-    ensureProps(multiaddrConnection)
-    return mockConnection(multiaddrConnection, {
-      direction: 'inbound',
-      registrar: this.registrar
-    })
-  }
-}
-
-export function mockUpgrader (init: MockUpgraderInit = {}) {
-  return new MockUpgrader(init)
-}

package/src/peer-discovery/index.ts

@@ -1,89 +0,0 @@
-import { expect } from 'aegir/chai'
-import { Multiaddr } from '@multiformats/multiaddr'
-import delay from 'delay'
-import pDefer from 'p-defer'
-import { start, stop } from '@libp2p/interfaces/startable'
-import type { TestSetup } from '../index.js'
-import type { PeerDiscovery } from '@libp2p/interfaces/peer-discovery'
-import type { Startable } from '@libp2p/interfaces/startable'
-
-export default (common: TestSetup<PeerDiscovery & Startable>) => {
-  describe('interface-peer-discovery compliance tests', () => {
-    let discovery: PeerDiscovery & Startable
-
-    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()
-
-      await start(discovery)
-
-      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(Multiaddr.isMultiaddr(m)).to.eql(true))
-
-        defer.resolve()
-      })
-
-      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()
-
-      await start(discovery)
-
-      discovery.addEventListener('peer', () => {
-        deferStart.resolve()
-      })
-
-      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

@@ -1,115 +0,0 @@
-import { expect } from 'aegir/chai'
-import sinon from 'sinon'
-import pDefer from 'p-defer'
-import pWaitFor from 'p-wait-for'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import delay from 'delay'
-import type { TestSetup } from '../index.js'
-import type { PubSub } from '@libp2p/interfaces/pubsub'
-import type { PubSubArgs } from './index.js'
-import type { Components } from '@libp2p/interfaces/components'
-import { createComponents } from './utils.js'
-import { isStartable, start, stop } from '@libp2p/interfaces/startable'
-import { mockNetwork } from '../mocks/connection-manager.js'
-
-const topic = 'foo'
-const data = uint8ArrayFromString('bar')
-
-export default (common: TestSetup<PubSub, PubSubArgs>) => {
-  describe('pubsub api', () => {
-    let pubsub: PubSub
-    let components: Components
-
-    // Create pubsub router
-    beforeEach(async () => {
-      mockNetwork.reset()
-      components = await createComponents()
-
-      pubsub = components.setPubSub(await common.setup({
-        components,
-        init: {
-          emitSelf: true
-        }
-      }))
-    })
-
-    afterEach(async () => {
-      sinon.restore()
-      await stop(components)
-      await common.teardown()
-      mockNetwork.reset()
-    })
-
-    it('can start correctly', async () => {
-      if (!isStartable(pubsub)) {
-        return
-      }
-
-      sinon.spy(components.getRegistrar(), 'register')
-
-      await start(components)
-
-      expect(pubsub.isStarted()).to.equal(true)
-      expect(components.getRegistrar().register).to.have.property('callCount', 1)
-    })
-
-    it('can stop correctly', async () => {
-      if (!isStartable(pubsub)) {
-        return
-      }
-
-      sinon.spy(components.getRegistrar(), 'unregister')
-
-      await start(components)
-      await stop(components)
-
-      expect(pubsub.isStarted()).to.equal(false)
-      expect(components.getRegistrar().unregister).to.have.property('callCount', 1)
-    })
-
-    it('can subscribe and unsubscribe correctly', async () => {
-      const handler = () => {
-        throw new Error('a message should not be received')
-      }
-
-      await start(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(components)
-    })
-
-    it('can subscribe and publish correctly', async () => {
-      const defer = pDefer()
-
-      await start(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(components)
-    })
-  })
-}