@libp2p/interface-compliance-tests 1.0.5 → 1.1.0

package/src/transport/utils/index.ts

@@ -1,10 +1,16 @@
 import { expect } from 'aegir/utils/chai.js'
-import type { Upgrader, MultiaddrConnection } from '@libp2p/interfaces/transport'
-import type { Connection, StreamData } from '@libp2p/interfaces/connection'
-import type { MuxedStream } from '@libp2p/interfaces/stream-muxer'
 import { pair } from 'it-pair'
 import { PeerId } from '@libp2p/peer-id'
 import * as PeerIdFactory from '@libp2p/peer-id-factory'
+import { pushable } from 'it-pushable'
+import drain from 'it-drain'
+import { Multiaddr } from '@multiformats/multiaddr'
+import { pipe } from 'it-pipe'
+import type { Upgrader, MultiaddrConnection } from '@libp2p/interfaces/transport'
+import type { Connection, Stream, Metadata, ProtocolStream } from '@libp2p/interfaces/connection'
+import type { Muxer } from '@libp2p/interfaces/stream-muxer'
+import type { Duplex } from 'it-stream-types'
+
 /**
  * A tick is considered valid if it happened between now
  * and `ms` milliseconds ago
@@ -23,51 +29,105 @@ export function isValidTick (date?: number, ms: number = 5000) {
   return false
 }
 
-export function mockUpgrader () {
+export function mockMultiaddrConnection (source: Duplex<Uint8Array>): MultiaddrConnection {
+  const maConn: MultiaddrConnection = {
+    ...source,
+    async close () {
+
+    },
+    timeline: {
+      open: Date.now()
+    },
+    remoteAddr: new Multiaddr('/ip4/127.0.0.1/tcp/4001')
+  }
+
+  return maConn
+}
+
+export function mockMuxer (): Muxer {
+  let streamId = 0
+  let streams: Stream[] = []
+  const p = pushable<Uint8Array>()
+
+  const muxer: Muxer = {
+    source: p,
+    sink: async (source) => {
+      await drain(source)
+    },
+    get streams () {
+      return streams
+    },
+    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
+        }
+      }
+
+      return stream
+    }
+  }
+
+  return muxer
+}
+
+export interface MockUpgraderOptions {
+  muxer?: Muxer
+}
+
+export function mockUpgrader (options: MockUpgraderOptions = {}) {
   const ensureProps = (multiaddrConnection: MultiaddrConnection) => {
-    ['sink', 'source', 'remoteAddr', 'conn', 'timeline', 'close'].forEach(prop => {
+    ['sink', 'source', 'remoteAddr', 'timeline', 'close'].forEach(prop => {
       expect(multiaddrConnection).to.have.property(prop)
     })
     expect(isValidTick(multiaddrConnection.timeline.open)).to.equal(true)
     return multiaddrConnection
   }
+
+  const muxer = options.muxer ?? mockMuxer()
+
   const upgrader: Upgrader = {
     async upgradeOutbound (multiaddrConnection) {
       ensureProps(multiaddrConnection)
-      return await createConnection(multiaddrConnection, 'outbound')
+      return await createConnection(multiaddrConnection, 'outbound', muxer)
     },
     async upgradeInbound (multiaddrConnection) {
       ensureProps(multiaddrConnection)
-      return await createConnection(multiaddrConnection, 'inbound')
+      return await createConnection(multiaddrConnection, 'inbound', muxer)
     }
   }
 
   return upgrader
 }
 
-async function createConnection (maConn: MultiaddrConnection, direction: 'inbound' | 'outbound'): Promise<Connection> {
-  const localAddr = maConn.localAddr
+async function createConnection (maConn: MultiaddrConnection, direction: 'inbound' | 'outbound', muxer: Muxer): Promise<Connection> {
   const remoteAddr = maConn.remoteAddr
-
-  if (localAddr == null) {
-    throw new Error('No localAddr found on MultiaddrConnection')
-  }
-
-  const localPeerIdStr = localAddr.getPeerId()
   const remotePeerIdStr = remoteAddr.getPeerId()
-  const localPeer = localPeerIdStr != null ? PeerId.fromString(localPeerIdStr) : await PeerIdFactory.createEd25519PeerId()
   const remotePeer = remotePeerIdStr != null ? PeerId.fromString(remotePeerIdStr) : await PeerIdFactory.createEd25519PeerId()
 
-  const streams: MuxedStream[] = []
+  const streams: Stream[] = []
   let streamId = 0
 
   const registry = new Map()
 
+  void pipe(
+    maConn, muxer, maConn
+  )
+
   return {
     id: 'mock-connection',
-    localAddr,
     remoteAddr,
-    localPeer,
     remotePeer,
     stat: {
       status: 'OPEN',
@@ -80,26 +140,17 @@ async function createConnection (maConn: MultiaddrConnection, direction: 'inboun
     tags: [],
     streams,
     newStream: async (protocols) => {
+      if (!Array.isArray(protocols)) {
+        protocols = [protocols]
+      }
+
       if (protocols.length === 0) {
         throw new Error('protocols must have a length')
       }
 
-      const echo = pair<Uint8Array>()
-
       const id = `${streamId++}`
-      const stream: MuxedStream = {
-        id,
-        sink: echo.sink,
-        source: echo.source,
-        close: () => {},
-        abort: () => {},
-        reset: () => {},
-        timeline: {
-          open: 0
-        }
-      }
-
-      const streamData = {
+      const stream: Stream = muxer.newStream(id)
+      const streamData: ProtocolStream = {
         protocol: protocols[0],
         stream
       }
@@ -108,7 +159,7 @@ async function createConnection (maConn: MultiaddrConnection, direction: 'inboun
 
       return streamData
     },
-    addStream: (muxedStream: MuxedStream, streamData: StreamData) => {
+    addStream: (stream: Stream, metadata: Metadata) => {
 
     },
     removeStream: (id: string) => {

package/src/utils/mock-connection-gater.ts

@@ -0,0 +1,14 @@
+
+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/utils/mock-connection.ts

@@ -0,0 +1,66 @@
+import { PeerId } from '@libp2p/peer-id'
+import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+import { pipe } from 'it-pipe'
+import type { MultiaddrConnection } from '@libp2p/interfaces/transport'
+import type { Connection, Stream, Metadata, ProtocolStream } from '@libp2p/interfaces/connection'
+import type { Muxer } from '@libp2p/interfaces/stream-muxer'
+
+export async function mockConnection (maConn: MultiaddrConnection, direction: 'inbound' | 'outbound', muxer: Muxer): Promise<Connection> {
+  const remoteAddr = maConn.remoteAddr
+  const remotePeerIdStr = remoteAddr.getPeerId()
+  const remotePeer = remotePeerIdStr != null ? PeerId.fromString(remotePeerIdStr) : await createEd25519PeerId()
+
+  const streams: Stream[] = []
+  let streamId = 0
+
+  const registry = new Map()
+
+  void pipe(
+    maConn, muxer, maConn
+  )
+
+  return {
+    id: 'mock-connection',
+    remoteAddr,
+    remotePeer,
+    stat: {
+      status: 'OPEN',
+      direction,
+      timeline: maConn.timeline,
+      multiplexer: 'test-multiplexer',
+      encryption: 'yes-yes-very-secure'
+    },
+    registry,
+    tags: [],
+    streams,
+    newStream: async (protocols) => {
+      if (!Array.isArray(protocols)) {
+        protocols = [protocols]
+      }
+
+      if (protocols.length === 0) {
+        throw new Error('protocols must have a length')
+      }
+
+      const id = `${streamId++}`
+      const stream: Stream = muxer.newStream(id)
+      const streamData: ProtocolStream = {
+        protocol: protocols[0],
+        stream
+      }
+
+      registry.set(id, streamData)
+
+      return streamData
+    },
+    addStream: (stream: Stream, metadata: Metadata) => {
+
+    },
+    removeStream: (id: string) => {
+      registry.delete(id)
+    },
+    close: async () => {
+      await maConn.close()
+    }
+  }
+}

package/src/utils/mock-multiaddr-connection.ts

@@ -0,0 +1,18 @@
+import { Multiaddr } from '@multiformats/multiaddr'
+import type { MultiaddrConnection } from '@libp2p/interfaces/transport'
+import type { Duplex } from 'it-stream-types'
+
+export function mockMultiaddrConnection (source: Duplex<Uint8Array>): MultiaddrConnection {
+  const maConn: MultiaddrConnection = {
+    ...source,
+    async close () {
+
+    },
+    timeline: {
+      open: Date.now()
+    },
+    remoteAddr: new Multiaddr('/ip4/127.0.0.1/tcp/4001')
+  }
+
+  return maConn
+}

package/src/utils/mock-muxer.ts

@@ -0,0 +1,43 @@
+import { pair } from 'it-pair'
+import { pushable } from 'it-pushable'
+import drain from 'it-drain'
+import type { Stream } from '@libp2p/interfaces/connection'
+import type { Muxer } from '@libp2p/interfaces/stream-muxer'
+
+export function mockMuxer (): Muxer {
+  let streamId = 0
+  let streams: Stream[] = []
+  const p = pushable<Uint8Array>()
+
+  const muxer: Muxer = {
+    source: p,
+    sink: async (source) => {
+      await drain(source)
+    },
+    get streams () {
+      return streams
+    },
+    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
+        }
+      }
+
+      return stream
+    }
+  }
+
+  return muxer
+}

package/src/utils/mock-upgrader.ts

@@ -0,0 +1,33 @@
+import { expect } from 'aegir/utils/chai.js'
+import { mockMuxer } from './mock-muxer.js'
+import { mockConnection } from './mock-connection.js'
+import type { Upgrader, MultiaddrConnection } from '@libp2p/interfaces/transport'
+import type { Muxer } from '@libp2p/interfaces/stream-muxer'
+
+export interface MockUpgraderOptions {
+  muxer?: Muxer
+}
+
+export function mockUpgrader (options: MockUpgraderOptions = {}) {
+  const ensureProps = (multiaddrConnection: MultiaddrConnection) => {
+    ['sink', 'source', 'remoteAddr', 'timeline', 'close'].forEach(prop => {
+      expect(multiaddrConnection).to.have.property(prop)
+    })
+    return multiaddrConnection
+  }
+
+  const muxer = options.muxer ?? mockMuxer()
+
+  const upgrader: Upgrader = {
+    async upgradeOutbound (multiaddrConnection) {
+      ensureProps(multiaddrConnection)
+      return await mockConnection(multiaddrConnection, 'outbound', muxer)
+    },
+    async upgradeInbound (multiaddrConnection) {
+      ensureProps(multiaddrConnection)
+      return await mockConnection(multiaddrConnection, 'inbound', muxer)
+    }
+  }
+
+  return upgrader
+}