@libp2p/interface-compliance-tests 0.2.0 → 1.0.3

package/src/stream-muxer/base-test.ts

@@ -1,24 +1,29 @@
 import { expect } from 'aegir/utils/chai.js'
-// @ts-expect-error no types
-import pair from 'it-pair/duplex.js'
+import { duplexPair } from 'it-pair/duplex'
 import { pipe } from 'it-pipe'
-import { collect, map, consume } from 'streaming-iterables'
+import drain from 'it-drain'
+import map from 'it-map'
+import all from 'it-all'
 import defer from 'p-defer'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { isValidTick } from '../transport/utils/index.js'
+import type { DeferredPromise } from 'p-defer'
 import type { TestSetup } from '../index.js'
 import type { Muxer, MuxerOptions, MuxedStream } from '@libp2p/interfaces/stream-muxer'
-import { isValidTick } from '../transport/utils/index.js'
+import type { Source } from 'it-stream-types'
 
-function close (stream: MuxedStream) {
-  return pipe([], stream, consume)
+async function close (stream: MuxedStream) {
+  return await pipe([], stream, drain)
 }
 
 export default (common: TestSetup<Muxer, MuxerOptions>) => {
   describe('base', () => {
     it('Open a stream from the dialer', async () => {
-      const p = pair()
+      const p = duplexPair<Uint8Array>()
       const dialer = await common.setup()
-      const onStreamPromise: defer.DeferredPromise<MuxedStream> = defer()
-      const onStreamEndPromise: defer.DeferredPromise<MuxedStream> = defer()
+      const onStreamPromise: DeferredPromise<MuxedStream> = defer()
+      const onStreamEndPromise: DeferredPromise<MuxedStream> = defer()
 
       const listener = await common.setup({
         onStream: stream => {
@@ -29,8 +34,8 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
         }
       })
 
-      pipe(p[0], dialer, p[0])
-      pipe(p[1], listener, p[1])
+      void pipe(p[0], dialer.newStream('/test/stream'), p[0])
+      void pipe(p[1], listener.newStream('/test/stream'), p[1])
 
       const conn = dialer.newStream()
       expect(dialer.streams).to.include(conn)
@@ -40,7 +45,7 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
       expect(isValidTick(stream.timeline.open)).to.equal(true)
       // Make sure the stream is being tracked
       expect(listener.streams).to.include(stream)
-      close(stream)
+      void close(stream)
 
       // Make sure stream is closed properly
       const endedStream = await onStreamEndPromise.promise
@@ -61,8 +66,8 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
     })
 
     it('Open a stream from the listener', async () => {
-      const p = pair()
-      const onStreamPromise: defer.DeferredPromise<MuxedStream> = defer()
+      const p = duplexPair<Uint8Array>()
+      const onStreamPromise: DeferredPromise<MuxedStream> = defer()
       const dialer = await common.setup({
         onStream: stream => {
           onStreamPromise.resolve(stream)
@@ -71,8 +76,8 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
 
       const listener = await common.setup()
 
-      pipe(p[0], dialer, p[0])
-      pipe(p[1], listener, p[1])
+      void pipe(p[0], dialer.newStream('/test/stream'), p[0])
+      void pipe(p[1], listener.newStream('/test/stream'), p[1])
 
       const conn = listener.newStream()
 
@@ -86,9 +91,9 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
     })
 
     it('Open a stream on both sides', async () => {
-      const p = pair()
-      const onDialerStreamPromise: defer.DeferredPromise<MuxedStream> = defer()
-      const onListenerStreamPromise: defer.DeferredPromise<MuxedStream> = defer()
+      const p = duplexPair<Uint8Array>()
+      const onDialerStreamPromise: DeferredPromise<MuxedStream> = defer()
+      const onListenerStreamPromise: DeferredPromise<MuxedStream> = defer()
       const dialer = await common.setup({
         onStream: stream => {
           onDialerStreamPromise.resolve(stream)
@@ -100,8 +105,8 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
         }
       })
 
-      pipe(p[0], dialer, p[0])
-      pipe(p[1], listener, p[1])
+      void pipe(p[0], dialer.newStream('/test/stream'), p[0])
+      void pipe(p[1], listener.newStream('/test/stream'), p[1])
 
       const listenerConn = listener.newStream()
       const dialerConn = dialer.newStream()
@@ -117,10 +122,10 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
     })
 
     it('Open a stream on one side, write, open a stream on the other side', async () => {
-      const toString = map((c: string) => c.slice().toString())
-      const p = pair()
-      const onDialerStreamPromise: defer.DeferredPromise<MuxedStream> = defer()
-      const onListenerStreamPromise: defer.DeferredPromise<MuxedStream> = defer()
+      const toString = (source: Source<Uint8Array>) => map(source, (u) => uint8ArrayToString(u))
+      const p = duplexPair<Uint8Array>()
+      const onDialerStreamPromise: DeferredPromise<MuxedStream> = defer()
+      const onListenerStreamPromise: DeferredPromise<MuxedStream> = defer()
       const dialer = await common.setup({
         onStream: stream => {
           onDialerStreamPromise.resolve(stream)
@@ -132,22 +137,22 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
         }
       })
 
-      pipe(p[0], dialer, p[0])
-      pipe(p[1], listener, p[1])
+      void pipe(p[0], dialer.newStream('/test/stream'), p[0])
+      void pipe(p[1], listener.newStream('/test/stream'), p[1])
 
       const dialerConn = dialer.newStream()
       const listenerConn = listener.newStream()
 
-      pipe(['hey'], dialerConn)
-      pipe(['hello'], listenerConn)
+      void pipe([uint8ArrayFromString('hey')], dialerConn)
+      void pipe([uint8ArrayFromString('hello')], listenerConn)
 
       const listenerStream = await onListenerStreamPromise.promise
       const dialerStream = await onDialerStreamPromise.promise
 
-      const listenerChunks = await pipe(listenerStream, toString, collect)
+      const listenerChunks = await pipe(listenerStream, toString, async (source) => await all(source))
       expect(listenerChunks).to.be.eql(['hey'])
 
-      const dialerChunks = await pipe(dialerStream, toString, collect)
+      const dialerChunks = await pipe(dialerStream, toString, async (source) => await all(source))
       expect(dialerChunks).to.be.eql(['hello'])
     })
   })

package/src/stream-muxer/close-test.ts

@@ -1,11 +1,10 @@
 /* eslint max-nested-callbacks: ["error", 8] */
-// @ts-expect-error no types
-import pair from 'it-pair/duplex.js'
 import { pipe } from 'it-pipe'
-import { consume } from 'streaming-iterables'
-import { source, duplex } from 'abortable-iterator'
+import { duplexPair } from 'it-pair/duplex'
+import { abortableSource, abortableDuplex } from 'abortable-iterator'
 import AbortController from 'abort-controller'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import drain from 'it-drain'
 import type { TestSetup } from '../index.js'
 import type { Muxer, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
 import type { Connection } from '@libp2p/interfaces/connection'
@@ -47,16 +46,16 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
       const mockUpgrade = async (maConn: any) => {
         const muxer = await common.setup({
           onStream: (stream) => {
-            pipe(stream, stream)
+            void pipe(stream, stream)
           }
         })
-        pipe(maConn, muxer, maConn)
+        pipe(maConn, muxer.newStream('/test/stream'), maConn)
         return mockConn(muxer)
       }
 
-      const [local, remote] = pair()
+      const [local, remote] = duplexPair<Uint8Array>()
       const controller = new AbortController()
-      const abortableRemote = duplex(remote, controller.signal, {
+      const abortableRemote = abortableDuplex(remote, controller.signal, {
         returnOnAbort: true
       })
 
@@ -69,8 +68,8 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
       // close the remote in a bit
       setTimeout(() => controller.abort(), 50)
 
-      const s1Result = pipe(infiniteRandom, s1, consume)
-      const s2Result = pipe(infiniteRandom, s2, consume)
+      const s1Result = pipe(infiniteRandom, s1.stream, drain)
+      const s2Result = pipe(infiniteRandom, s2.stream, drain)
 
       // test is complete when all muxed streams have closed
       await s1Result
@@ -78,16 +77,16 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
     })
 
     it('closing one of the muxed streams doesn\'t close others', async () => {
-      const p = pair()
+      const p = duplexPair<Uint8Array>()
       const dialer = await common.setup()
 
       // Listener is echo server :)
       const listener = await common.setup({
-        onStream: (stream) => pipe(stream, stream)
+        onStream: async (stream) => await pipe(stream, stream)
       })
 
-      pipe(p[0], dialer, p[0])
-      pipe(p[1], listener, p[1])
+      void pipe(p[0], dialer.newStream('/test/stream'), p[0])
+      void pipe(p[1], listener.newStream('/test/stream'), p[1])
 
       const stream = dialer.newStream()
       const streams = Array.from(Array(5), () => dialer.newStream())
@@ -99,8 +98,8 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
         controllers.push(controller)
 
         try {
-          const abortableRand = source(infiniteRandom, controller.signal, { abortCode: 'ERR_TEST_ABORT' })
-          await pipe(abortableRand, stream, consume)
+          const abortableRand = abortableSource(infiniteRandom, controller.signal, { abortCode: 'ERR_TEST_ABORT' })
+          await pipe(abortableRand, stream, drain)
         } catch (err: any) {
           if (err.code !== 'ERR_TEST_ABORT') throw err
         }
@@ -110,7 +109,7 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
 
       // Pause, and then send some data and close the first stream
       await pause(50)
-      await pipe([randomBuffer()], stream, consume)
+      await pipe([randomBuffer()], stream, drain)
       closed = true
 
       // Abort all the other streams later

package/src/stream-muxer/spawner.ts

@@ -1,44 +1,45 @@
 import { expect } from 'aegir/utils/chai.js'
-// @ts-expect-error no types
-import pair from 'it-pair/duplex.js'
+import { duplexPair } from 'it-pair/duplex'
 import { pipe } from 'it-pipe'
 import pLimit from 'p-limit'
-import { collect, consume } from 'streaming-iterables'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import drain from 'it-drain'
+import all from 'it-all'
 import type { Muxer, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
 
 export default async (createMuxer: (options?: MuxerOptions) => Promise<Muxer>, nStreams: number, nMsg: number, limit?: number) => {
-  const [dialerSocket, listenerSocket] = pair()
+  const [dialerSocket, listenerSocket] = duplexPair<Uint8Array>()
 
-  const msg = 'simple msg'
+  const msg = uint8ArrayFromString('simple msg')
 
   const listener = await createMuxer({
     onStream: async (stream) => {
       await pipe(
         stream,
-        consume
+        drain
       )
 
-      pipe([], stream)
+      void pipe([], stream)
     }
   })
 
   const dialer = await createMuxer()
 
-  pipe(listenerSocket, listener, listenerSocket)
-  pipe(dialerSocket, dialer, dialerSocket)
+  void pipe(listenerSocket, listener.newStream('/test/stream'), listenerSocket)
+  void pipe(dialerSocket, dialer.newStream('/test/stream'), dialerSocket)
 
   const spawnStream = async () => {
     const stream = dialer.newStream()
     expect(stream).to.exist // eslint-disable-line
 
     const res = await pipe(
-      (function * () {
+      (async function * () {
         for (let i = 0; i < nMsg; i++) {
-          yield new Promise(resolve => resolve(msg))
+          yield msg
         }
-      })(),
+      }()),
       stream,
-      collect
+      async (source) => await all(source)
     )
 
     expect(res).to.be.eql([])

package/src/transport/dial-test.ts

@@ -1,12 +1,12 @@
 import { expect } from 'aegir/utils/chai.js'
 import { isValidTick, mockUpgrader } from './utils/index.js'
-// @ts-expect-error no types
-import goodbye from 'it-goodbye'
-import { collect } from 'streaming-iterables'
+import { goodbye } from 'it-goodbye'
+import all from 'it-all'
 import { pipe } from 'it-pipe'
 import AbortController from 'abort-controller'
 import { AbortError } from '@libp2p/interfaces/errors'
 import sinon from 'sinon'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import type { TestSetup } from '../index.js'
 import type { Transport, Listener } from '@libp2p/interfaces/transport'
 import type { TransportTestFixtures, SetupArgs, Connector } from './index.js'
@@ -43,7 +43,7 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
       const upgradeSpy = sinon.spy(upgrader, 'upgradeOutbound')
       const conn = await transport.dial(addrs[0])
       const { stream } = await conn.newStream(['/hello'])
-      const s = goodbye({ source: ['hey'], sink: collect })
+      const s = goodbye({ source: [uint8ArrayFromString('hey')], sink: async (source) => await all(source) })
 
       const result = await pipe(s, stream, s)
 

package/src/transport/listen-test.ts

@@ -16,7 +16,7 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
   describe('listen', () => {
     const upgrader = mockUpgrader()
     let addrs: Multiaddr[]
-    let transport: Transport<any, any>
+    let transport: Transport
 
     before(async () => {
       ({ transport, addrs } = await common.setup({ upgrader }))
@@ -31,7 +31,7 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
     })
 
     it('simple', async () => {
-      const listener = transport.createListener({}, (conn) => {})
+      const listener = transport.createListener()
       await listener.listen(addrs[0])
       await listener.close()
     })
@@ -40,8 +40,10 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
       const upgradeSpy = sinon.spy(upgrader, 'upgradeInbound')
       const listenerConns: Connection[] = []
 
-      const listener = transport.createListener({}, (conn) => {
-        listenerConns.push(conn)
+      const listener = transport.createListener({
+        handler: (conn) => {
+          listenerConns.push(conn)
+        }
       })
 
       // Listen
@@ -83,8 +85,10 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
     it('should not handle connection if upgradeInbound throws', async () => {
       sinon.stub(upgrader, 'upgradeInbound').throws()
 
-      const listener = transport.createListener(() => {
-        throw new Error('should not handle the connection if upgradeInbound throws')
+      const listener = transport.createListener({
+        handler: () => {
+          throw new Error('should not handle the connection if upgradeInbound throws')
+        }
       })
 
       // Listen
@@ -100,7 +104,7 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
     describe('events', () => {
       it('connection', async () => {
         const upgradeSpy = sinon.spy(upgrader, 'upgradeInbound')
-        const listener = transport.createListener({})
+        const listener = transport.createListener()
         const deferred = defer()
         let conn
 
@@ -122,7 +126,7 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
       })
 
       it('listening', (done) => {
-        const listener = transport.createListener({})
+        const listener = transport.createListener()
         listener.on('listening', () => {
           listener.close().then(done, done)
         })
@@ -130,7 +134,7 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
       })
 
       it('error', (done) => {
-        const listener = transport.createListener({})
+        const listener = transport.createListener()
         listener.on('error', (err) => {
           expect(err).to.exist()
           listener.close().then(done, done)
@@ -139,7 +143,7 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
       })
 
       it('close', (done) => {
-        const listener = transport.createListener({})
+        const listener = transport.createListener()
         listener.on('close', done)
 
         void (async () => {

package/src/transport/utils/index.ts

@@ -2,8 +2,7 @@ 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'
-// @ts-expect-error no types
-import pair from 'it-pair'
+import { pair } from 'it-pair'
 import { PeerId } from '@libp2p/peer-id'
 import * as PeerIdFactory from '@libp2p/peer-id-factory'
 /**
@@ -59,7 +58,7 @@ async function createConnection (maConn: MultiaddrConnection, direction: 'inboun
   const localPeer = localPeerIdStr != null ? PeerId.fromString(localPeerIdStr) : await PeerIdFactory.createEd25519PeerId()
   const remotePeer = remotePeerIdStr != null ? PeerId.fromString(remotePeerIdStr) : await PeerIdFactory.createEd25519PeerId()
 
-  const streams: Array<MuxedStream<Uint8Array>> = []
+  const streams: MuxedStream[] = []
   let streamId = 0
 
   const registry = new Map()
@@ -85,7 +84,7 @@ async function createConnection (maConn: MultiaddrConnection, direction: 'inboun
         throw new Error('protocols must have a length')
       }
 
-      const echo = pair()
+      const echo = pair<Uint8Array>()
 
       const id = `${streamId++}`
       const stream: MuxedStream = {
@@ -97,8 +96,7 @@ async function createConnection (maConn: MultiaddrConnection, direction: 'inboun
         reset: () => {},
         timeline: {
           open: 0
-        },
-        [Symbol.asyncIterator]: echo.source
+        }
       }
 
       const streamData = {