@libp2p/interface-compliance-tests 2.0.2 → 3.0.1

package/src/connection/connection.ts

@@ -1,176 +0,0 @@
-import { expect } from 'aegir/chai'
-import sinon from 'sinon'
-import type { TestSetup } from '../index.js'
-import type { Connection } from '@libp2p/interfaces/connection'
-
-export default (test: TestSetup<Connection>) => {
-  describe('connection', () => {
-    describe('open connection', () => {
-      let connection: Connection
-
-      beforeEach(async () => {
-        connection = await test.setup()
-      })
-
-      afterEach(async () => {
-        await connection.close()
-        await test.teardown()
-      })
-
-      it('should have properties set', () => {
-        expect(connection.id).to.exist()
-        expect(connection.remotePeer).to.exist()
-        expect(connection.remoteAddr).to.exist()
-        expect(connection.stat.status).to.equal('OPEN')
-        expect(connection.stat.timeline.open).to.exist()
-        expect(connection.stat.timeline.upgraded).to.exist()
-        expect(connection.stat.timeline.close).to.not.exist()
-        expect(connection.stat.direction).to.exist()
-        expect(connection.streams).to.eql([])
-        expect(connection.tags).to.eql([])
-      })
-
-      it('should get the metadata of an open connection', () => {
-        const stat = connection.stat
-
-        expect(stat.status).to.equal('OPEN')
-        expect(stat.direction).to.exist()
-        expect(stat.timeline.open).to.exist()
-        expect(stat.timeline.upgraded).to.exist()
-        expect(stat.timeline.close).to.not.exist()
-      })
-
-      it('should return an empty array of streams', () => {
-        const streams = connection.streams
-
-        expect(streams).to.eql([])
-      })
-
-      it('should be able to create a new stream', async () => {
-        const protocolToUse = '/echo/0.0.1'
-        const { stream, protocol } = await connection.newStream([protocolToUse])
-
-        expect(protocol).to.equal(protocolToUse)
-
-        const connStreams = await connection.streams
-
-        expect(stream).to.exist()
-        expect(connStreams).to.exist()
-        expect(connStreams).to.have.lengthOf(1)
-        expect(connStreams[0]).to.equal(stream)
-      })
-    })
-
-    describe('close connection', () => {
-      let connection: Connection
-      let timelineProxy
-      const proxyHandler = {
-        set () {
-          // @ts-expect-error - TS fails to infer here
-          return Reflect.set(...arguments)
-        }
-      }
-
-      beforeEach(async () => {
-        timelineProxy = new Proxy({
-          open: Date.now() - 10,
-          upgraded: Date.now()
-        }, proxyHandler)
-
-        connection = await test.setup({
-          stat: {
-            timeline: timelineProxy,
-            direction: 'outbound',
-            encryption: '/crypto/1.0.0',
-            multiplexer: '/muxer/1.0.0'
-          }
-        })
-      })
-
-      afterEach(async () => {
-        await test.teardown()
-      })
-
-      it('should be able to close the connection after being created', async () => {
-        expect(connection.stat.timeline.close).to.not.exist()
-        await connection.close()
-
-        expect(connection.stat.timeline.close).to.exist()
-        expect(connection.stat.status).to.equal('CLOSED')
-      })
-
-      it('should be able to close the connection after opening a stream', async () => {
-        // Open stream
-        const protocol = '/echo/0.0.1'
-        await connection.newStream([protocol])
-
-        // Close connection
-        expect(connection.stat.timeline.close).to.not.exist()
-        await connection.close()
-
-        expect(connection.stat.timeline.close).to.exist()
-        expect(connection.stat.status).to.equal('CLOSED')
-      })
-
-      it('should properly track streams', async () => {
-        // Open stream
-        const protocol = '/echo/0.0.1'
-        const { stream } = await connection.newStream([protocol])
-        const trackedStream = connection.registry.get(stream.id)
-        expect(trackedStream).to.have.property('protocol', protocol)
-
-        // Close stream
-        await stream.close()
-
-        expect(connection.registry.get(stream.id)).to.not.exist()
-      })
-
-      it('should support a proxy on the timeline', async () => {
-        sinon.spy(proxyHandler, 'set')
-        expect(connection.stat.timeline.close).to.not.exist()
-
-        await connection.close()
-        // @ts-expect-error - fails to infer callCount
-        expect(proxyHandler.set.callCount).to.equal(1)
-        // @ts-expect-error - fails to infer getCall
-        const [obj, key, value] = proxyHandler.set.getCall(0).args
-        expect(obj).to.eql(connection.stat.timeline)
-        expect(key).to.equal('close')
-        expect(value).to.be.a('number').that.equals(connection.stat.timeline.close)
-      })
-
-      it('should fail to create a new stream if the connection is closing', async () => {
-        expect(connection.stat.timeline.close).to.not.exist()
-        const p = connection.close()
-
-        try {
-          const protocol = '/echo/0.0.1'
-          await connection.newStream([protocol])
-        } catch (err: any) {
-          expect(err).to.exist()
-          return
-        } finally {
-          await p
-        }
-
-        throw new Error('should fail to create a new stream if the connection is closing')
-      })
-
-      it('should fail to create a new stream if the connection is closed', async () => {
-        expect(connection.stat.timeline.close).to.not.exist()
-        await connection.close()
-
-        try {
-          const protocol = '/echo/0.0.1'
-          await connection.newStream([protocol])
-        } catch (err: any) {
-          expect(err).to.exist()
-          expect(err.code).to.equal('ERR_CONNECTION_CLOSED')
-          return
-        }
-
-        throw new Error('should fail to create a new stream if the connection is closing')
-      })
-    })
-  })
-}

package/src/connection/index.ts

@@ -1,7 +0,0 @@
-import connectionSuite from './connection.js'
-import type { TestSetup } from '../index.js'
-import type { Connection } from '@libp2p/interfaces/connection'
-
-export default (test: TestSetup<Connection>) => {
-  connectionSuite(test)
-}

package/src/connection-encrypter/index.ts

@@ -1,104 +0,0 @@
-import { expect } from 'aegir/chai'
-import { pipe } from 'it-pipe'
-import * as PeerIdFactory from '@libp2p/peer-id-factory'
-import all from 'it-all'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import peers from '../utils/peers.js'
-import { UnexpectedPeerError } from '@libp2p/interfaces/connection-encrypter/errors'
-import { createMaConnPair } from './utils/index.js'
-import type { TestSetup } from '../index.js'
-import type { ConnectionEncrypter } from '@libp2p/interfaces/connection-encrypter'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
-import type { Source } from 'it-stream-types'
-
-export default (common: TestSetup<ConnectionEncrypter>) => {
-  describe('interface-connection-encrypter compliance tests', () => {
-    let crypto: ConnectionEncrypter
-    let localPeer: PeerId
-    let remotePeer: PeerId
-    let mitmPeer: PeerId
-
-    before(async () => {
-      [
-        crypto,
-        localPeer,
-        remotePeer,
-        mitmPeer
-      ] = await Promise.all([
-        common.setup(),
-        PeerIdFactory.createFromJSON(peers[0]),
-        PeerIdFactory.createFromJSON(peers[1]),
-        PeerIdFactory.createFromJSON(peers[2])
-      ])
-    })
-
-    after(async () => {
-      await common.teardown()
-    })
-
-    it('has a protocol string', () => {
-      expect(crypto.protocol).to.exist()
-      expect(crypto.protocol).to.be.a('string')
-    })
-
-    it('it wraps the provided duplex connection', async () => {
-      const [localConn, remoteConn] = createMaConnPair()
-
-      const [
-        inboundResult,
-        outboundResult
-      ] = await Promise.all([
-        crypto.secureInbound(remotePeer, localConn),
-        crypto.secureOutbound(localPeer, remoteConn, remotePeer)
-      ])
-
-      // Echo server
-      void pipe(inboundResult.conn, inboundResult.conn)
-
-      // Send some data and collect the result
-      const input = uint8ArrayFromString('data to encrypt')
-      const result = await pipe(
-        [input],
-        outboundResult.conn,
-        // Convert BufferList to Buffer via slice
-        (source: Source<Uint8Array>) => (async function * toBuffer () {
-          for await (const chunk of source) {
-            yield chunk.slice()
-          }
-        })(),
-        async (source) => await all(source)
-      )
-
-      expect(result).to.eql([input])
-    })
-
-    it('should return the remote peer id', async () => {
-      const [localConn, remoteConn] = createMaConnPair()
-
-      const [
-        inboundResult,
-        outboundResult
-      ] = await Promise.all([
-        crypto.secureInbound(remotePeer, localConn),
-        crypto.secureOutbound(localPeer, remoteConn, remotePeer)
-      ])
-
-      // Inbound should return the initiator (local) peer
-      expect(inboundResult.remotePeer.toBytes()).to.equalBytes(localPeer.toBytes())
-      // Outbound should return the receiver (remote) peer
-      expect(outboundResult.remotePeer.toBytes()).to.equalBytes(remotePeer.toBytes())
-    })
-
-    it('inbound connections should verify peer integrity if known', async () => {
-      const [localConn, remoteConn] = createMaConnPair()
-
-      await Promise.all([
-        crypto.secureInbound(remotePeer, localConn, mitmPeer),
-        crypto.secureOutbound(localPeer, remoteConn, remotePeer)
-      ]).then(() => expect.fail(), (err) => {
-        expect(err).to.exist()
-        expect(err).to.have.property('code', UnexpectedPeerError.code)
-      })
-    })
-  })
-}

package/src/connection-encrypter/utils/index.ts

@@ -1,23 +0,0 @@
-import { duplexPair } from 'it-pair/duplex'
-import { Multiaddr } from '@multiformats/multiaddr'
-import type { MultiaddrConnection } from '@libp2p/interfaces/transport'
-import type { Duplex } from 'it-stream-types'
-
-export function createMaConnPair (): [MultiaddrConnection, MultiaddrConnection] {
-  const [local, remote] = duplexPair<Uint8Array>()
-
-  function duplexToMaConn (duplex: Duplex<Uint8Array>): MultiaddrConnection {
-    const output: MultiaddrConnection = {
-      ...duplex,
-      close: async () => {},
-      remoteAddr: new Multiaddr('/ip4/127.0.0.1/tcp/4001'),
-      timeline: {
-        open: Date.now()
-      }
-    }
-
-    return output
-  }
-
-  return [duplexToMaConn(local), duplexToMaConn(remote)]
-}

package/src/mocks/connection-encrypter.ts

@@ -1,110 +0,0 @@
-import { peerIdFromBytes } from '@libp2p/peer-id'
-import { handshake } from 'it-handshake'
-import { duplexPair } from 'it-pair/duplex'
-import { pipe } from 'it-pipe'
-import { UnexpectedPeerError } from '@libp2p/interfaces/connection-encrypter/errors'
-import { Multiaddr } from '@multiformats/multiaddr'
-import type { ConnectionEncrypter } from '@libp2p/interfaces/connection-encrypter'
-import type { Transform, Source } from 'it-stream-types'
-
-// A basic transform that does nothing to the data
-const transform = (): Transform<Uint8Array, Uint8Array> => {
-  return (source: Source<Uint8Array>) => (async function * () {
-    for await (const chunk of source) {
-      yield chunk
-    }
-  })()
-}
-
-export function mockConnectionEncrypter () {
-  const encrypter: ConnectionEncrypter = {
-    protocol: 'insecure',
-    secureInbound: async (localPeer, duplex, expectedPeer) => {
-      // 1. Perform a basic handshake.
-      const shake = handshake(duplex)
-      shake.write(localPeer.toBytes())
-      const remoteId = await shake.read()
-
-      if (remoteId == null) {
-        throw new Error('Could not read remote ID')
-      }
-
-      const remotePeer = peerIdFromBytes(remoteId.slice())
-      shake.rest()
-
-      if (expectedPeer != null && !expectedPeer.equals(remotePeer)) {
-        throw new UnexpectedPeerError()
-      }
-
-      // 2. Create your encryption box/unbox wrapper
-      const wrapper = duplexPair<Uint8Array>()
-      const encrypt = transform() // Use transform iterables to modify data
-      const decrypt = transform()
-
-      void pipe(
-        wrapper[0], // We write to wrapper
-        encrypt, // The data is encrypted
-        shake.stream, // It goes to the remote peer
-        decrypt, // Decrypt the incoming data
-        wrapper[0] // Pipe to the wrapper
-      )
-
-      return {
-        conn: {
-          ...wrapper[1],
-          close: async () => {},
-          localAddr: new Multiaddr('/ip4/127.0.0.1/tcp/4001'),
-          remoteAddr: new Multiaddr('/ip4/127.0.0.1/tcp/4002'),
-          timeline: {
-            open: Date.now()
-          },
-          conn: true
-        },
-        remotePeer,
-        remoteEarlyData: new Uint8Array(0)
-      }
-    },
-    secureOutbound: async (localPeer, duplex, remotePeer) => {
-      // 1. Perform a basic handshake.
-      const shake = handshake(duplex)
-      shake.write(localPeer.toBytes())
-      const remoteId = await shake.read()
-
-      if (remoteId == null) {
-        throw new Error('Could not read remote ID')
-      }
-
-      shake.rest()
-
-      // 2. Create your encryption box/unbox wrapper
-      const wrapper = duplexPair<Uint8Array>()
-      const encrypt = transform()
-      const decrypt = transform()
-
-      void pipe(
-        wrapper[0], // We write to wrapper
-        encrypt, // The data is encrypted
-        shake.stream, // It goes to the remote peer
-        decrypt, // Decrypt the incoming data
-        wrapper[0] // Pipe to the wrapper
-      )
-
-      return {
-        conn: {
-          ...wrapper[1],
-          close: async () => {},
-          localAddr: new Multiaddr('/ip4/127.0.0.1/tcp/4001'),
-          remoteAddr: new Multiaddr('/ip4/127.0.0.1/tcp/4002'),
-          timeline: {
-            open: Date.now()
-          },
-          conn: true
-        },
-        remotePeer: peerIdFromBytes(remoteId.slice()),
-        remoteEarlyData: new Uint8Array(0)
-      }
-    }
-  }
-
-  return encrypter
-}

package/src/mocks/connection-gater.ts

@@ -1,14 +0,0 @@
-
-export function mockConnectionGater () {
-  return {
-    denyDialPeer: async () => await Promise.resolve(false),
-    denyDialMultiaddr: async () => await Promise.resolve(false),
-    denyInboundConnection: async () => await Promise.resolve(false),
-    denyOutboundConnection: async () => await Promise.resolve(false),
-    denyInboundEncryptedConnection: async () => await Promise.resolve(false),
-    denyOutboundEncryptedConnection: async () => await Promise.resolve(false),
-    denyInboundUpgradedConnection: async () => await Promise.resolve(false),
-    denyOutboundUpgradedConnection: async () => await Promise.resolve(false),
-    filterMultiaddrForPeer: async () => await Promise.resolve(true)
-  }
-}

package/src/mocks/connection-manager.ts

@@ -1,141 +0,0 @@
-import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
-import type { Startable } from '@libp2p/interfaces/startable'
-import type { Connection } from '@libp2p/interfaces/connection'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
-import type { ConnectionManager, ConnectionManagerEvents } from '@libp2p/interfaces/connection-manager'
-import type { Components, Initializable } from '@libp2p/interfaces/src/components'
-import { connectionPair } from './connection.js'
-import errCode from 'err-code'
-
-class MockNetwork {
-  private components: Components[] = []
-
-  addNode (components: Components): void {
-    this.components.push(components)
-  }
-
-  getNode (peerId: PeerId): Components {
-    for (const components of this.components) {
-      if (peerId.equals(components.getPeerId())) {
-        return components
-      }
-    }
-
-    throw errCode(new Error('Peer not found'), 'ERR_PEER_NOT_FOUND')
-  }
-
-  reset () {
-    this.components = []
-  }
-}
-
-export const mockNetwork = new MockNetwork()
-
-class MockConnectionManager extends EventEmitter<ConnectionManagerEvents> implements ConnectionManager, Initializable, Startable {
-  private connections: Connection[] = []
-  private components?: Components
-  private started = false
-
-  init (components: Components) {
-    this.components = components
-  }
-
-  isStarted () {
-    return this.started
-  }
-
-  async start () {
-    this.started = true
-  }
-
-  async stop () {
-    for (const connection of this.connections) {
-      await this.closeConnections(connection.remotePeer)
-    }
-
-    this.started = false
-  }
-
-  getConnections (peerId?: PeerId): Connection[] {
-    if (peerId != null) {
-      return this.connections
-        .filter(c => c.remotePeer.toString() === peerId.toString())
-    }
-
-    return this.connections
-  }
-
-  async openConnection (peerId: PeerId) {
-    if (this.components == null) {
-      throw errCode(new Error('Not initialized'), 'ERR_NOT_INITIALIZED')
-    }
-
-    const existingConnections = this.getConnections(peerId)
-
-    if (existingConnections.length > 0) {
-      return existingConnections[0]
-    }
-
-    const componentsB = mockNetwork.getNode(peerId)
-
-    const [aToB, bToA] = connectionPair(this.components, componentsB)
-
-    // track connections
-    this.connections.push(aToB)
-    ;(componentsB.getConnectionManager() as MockConnectionManager).connections.push(bToA)
-
-    this.components.getConnectionManager().dispatchEvent(new CustomEvent<Connection>('peer:connect', {
-      detail: aToB
-    }))
-
-    for (const protocol of this.components.getRegistrar().getProtocols()) {
-      for (const topology of this.components.getRegistrar().getTopologies(protocol)) {
-        topology.onConnect(componentsB.getPeerId(), aToB)
-      }
-    }
-
-    componentsB.getConnectionManager().dispatchEvent(new CustomEvent<Connection>('peer:connect', {
-      detail: bToA
-    }))
-
-    for (const protocol of componentsB.getRegistrar().getProtocols()) {
-      for (const topology of componentsB.getRegistrar().getTopologies(protocol)) {
-        topology.onConnect(this.components.getPeerId(), bToA)
-      }
-    }
-
-    return aToB
-  }
-
-  async closeConnections (peerId: PeerId) {
-    if (this.components == null) {
-      throw errCode(new Error('Not initialized'), 'ERR_NOT_INITIALIZED')
-    }
-
-    const connections = this.getConnections(peerId)
-
-    if (connections.length === 0) {
-      return
-    }
-
-    const componentsB = mockNetwork.getNode(peerId)
-
-    for (const protocol of this.components.getRegistrar().getProtocols()) {
-      this.components.getRegistrar().getTopologies(protocol).forEach(topology => {
-        topology.onDisconnect(componentsB.getPeerId())
-      })
-    }
-
-    for (const conn of connections) {
-      await conn.close()
-    }
-
-    this.connections = this.connections.filter(c => !c.remotePeer.equals(peerId))
-
-    await componentsB.getConnectionManager().closeConnections(peerId)
-  }
-}
-
-export function mockConnectionManager () {
-  return new MockConnectionManager()
-}