@libp2p/interface-compliance-tests 1.1.8 → 1.1.12

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

@@ -27,10 +27,10 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
       const onStreamEndPromise: DeferredPromise<Stream> = defer()
 
       const listener = await common.setup({
-        onStream: stream => {
+        onIncomingStream: (stream) => {
           onStreamPromise.resolve(stream)
         },
-        onStreamEnd: stream => {
+        onStreamEnd: (stream) => {
           onStreamEndPromise.resolve(stream)
         }
       })
@@ -74,7 +74,7 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
       const p = duplexPair<Uint8Array>()
       const onStreamPromise: DeferredPromise<Stream> = defer()
       const dialer = await common.setup({
-        onStream: stream => {
+        onIncomingStream: (stream: Stream) => {
           onStreamPromise.resolve(stream)
         }
       })
@@ -103,12 +103,13 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
       const onDialerStreamPromise: DeferredPromise<Stream> = defer()
       const onListenerStreamPromise: DeferredPromise<Stream> = defer()
       const dialer = await common.setup({
-        onStream: stream => {
+        onIncomingStream: (stream) => {
           onDialerStreamPromise.resolve(stream)
         }
       })
+
       const listener = await common.setup({
-        onStream: stream => {
+        onIncomingStream: (stream) => {
           onListenerStreamPromise.resolve(stream)
         }
       })
@@ -116,20 +117,20 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
       void pipe(p[0], dialer, p[0])
       void pipe(p[1], listener, p[1])
 
-      const listenerConn = listener.newStream()
-      const dialerConn = dialer.newStream()
-
-      void drainAndClose(dialerConn)
-      void drainAndClose(listenerConn)
+      const dialerInitiatorStream = dialer.newStream()
+      const listenerInitiatorStream = listener.newStream()
 
-      const dialerStream = await onDialerStreamPromise.promise
-      const listenerStream = await onListenerStreamPromise.promise
+      await Promise.all([
+        drainAndClose(dialerInitiatorStream),
+        drainAndClose(listenerInitiatorStream),
+        onDialerStreamPromise.promise.then(async stream => await drainAndClose(stream)),
+        onListenerStreamPromise.promise.then(async stream => await drainAndClose(stream))
+      ])
 
-      await drainAndClose(dialerStream)
-      await drainAndClose(listenerStream)
-
-      await drainAndClose(dialer)
-      await drainAndClose(listener)
+      await Promise.all([
+        drainAndClose(dialer),
+        drainAndClose(listener)
+      ])
     })
 
     it('Open a stream on one side, write, open a stream on the other side', async () => {
@@ -138,12 +139,12 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
       const onDialerStreamPromise: DeferredPromise<Stream> = defer()
       const onListenerStreamPromise: DeferredPromise<Stream> = defer()
       const dialer = await common.setup({
-        onStream: stream => {
+        onIncomingStream: (stream) => {
           onDialerStreamPromise.resolve(stream)
         }
       })
       const listener = await common.setup({
-        onStream: stream => {
+        onIncomingStream: (stream) => {
           onListenerStreamPromise.resolve(stream)
         }
       })
@@ -157,13 +158,23 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
       void pipe([uint8ArrayFromString('hey')], dialerConn)
       void pipe([uint8ArrayFromString('hello')], listenerConn)
 
-      const listenerStream = await onListenerStreamPromise.promise
-      const dialerStream = await onDialerStreamPromise.promise
+      const [
+        dialerStream,
+        listenerStream
+      ] = await Promise.all([
+        onDialerStreamPromise.promise,
+        onListenerStreamPromise.promise
+      ])
+
+      const [
+        listenerChunks,
+        dialerChunks
+      ] = await Promise.all([
+        pipe(listenerStream, toString, async (source) => await all(source)),
+        pipe(dialerStream, toString, async (source) => await all(source))
+      ])
 
-      const listenerChunks = await pipe(listenerStream, toString, async (source) => await all(source))
       expect(listenerChunks).to.be.eql(['hey'])
-
-      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,16 +1,13 @@
 /* eslint max-nested-callbacks: ["error", 8] */
 import { pipe } from 'it-pipe'
 import { duplexPair } from 'it-pair/duplex'
-import { abortableSource, abortableDuplex } from 'abortable-iterator'
+import { abortableSource } from 'abortable-iterator'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import drain from 'it-drain'
-import { mockUpgrader } from '../mocks/upgrader.js'
-import { mockMultiaddrConnection } from '../mocks/multiaddr-connection.js'
 import { expect } from 'aegir/utils/chai.js'
 import delay from 'delay'
 import type { TestSetup } from '../index.js'
 import type { Muxer, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
-import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 
 function randomBuffer () {
   return uint8ArrayFromString(Math.random().toString())
@@ -28,38 +25,42 @@ const infiniteRandom = {
 export default (common: TestSetup<Muxer, MuxerOptions>) => {
   describe('close', () => {
     it('closing underlying socket closes streams', async () => {
-      const localPeer = await createEd25519PeerId()
-      const remotePeer = await createEd25519PeerId()
-      const muxer = await common.setup({
-        onStream: (stream) => {
-          void pipe(stream, drain)
-        }
-      })
-      const upgrader = mockUpgrader({ muxer })
+      let openedStreams = 0
+      const expectedStreams = 5
+      const dialer = await common.setup()
 
-      const [local, remote] = duplexPair<Uint8Array>()
-      const controller = new AbortController()
-      const abortableRemote = abortableDuplex(remote, controller.signal, {
-        returnOnAbort: true
+      // Listener is echo server :)
+      const listener = await common.setup({
+        onIncomingStream: (stream) => {
+          openedStreams++
+          void pipe(stream, stream)
+        }
       })
 
-      await upgrader.upgradeInbound(mockMultiaddrConnection(abortableRemote, localPeer))
-      const dialerConn = await upgrader.upgradeOutbound(mockMultiaddrConnection(local, remotePeer))
+      const p = duplexPair<Uint8Array>()
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
 
-      const s1 = await dialerConn.newStream([''])
-      const s2 = await dialerConn.newStream([''])
+      const streams = Array(expectedStreams).fill(0).map(() => dialer.newStream())
 
-      // close the remote in a bit
-      setTimeout(() => controller.abort(), 50)
+      void Promise.all(
+        streams.map(async stream => {
+          return await pipe(
+            infiniteRandom,
+            stream,
+            drain
+          )
+        })
+      )
 
-      const s1Result = pipe(infiniteRandom, s1.stream, drain)
-      const s2Result = pipe(infiniteRandom, s2.stream, drain)
+      expect(dialer.streams).to.have.lengthOf(expectedStreams)
 
-      // test is complete when all muxed streams have closed
-      await s1Result
-      await s2Result
+      // Pause, and then send some data and close the dialer
+      await delay(50)
+      await pipe([randomBuffer()], dialer, drain)
 
-      expect(muxer.streams).to.be.empty()
+      expect(openedStreams).to.have.equal(expectedStreams)
+      expect(dialer.streams).to.have.lengthOf(0)
     })
 
     it('closing one of the muxed streams doesn\'t close others', async () => {
@@ -68,7 +69,9 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
 
       // Listener is echo server :)
       const listener = await common.setup({
-        onStream: async (stream) => await pipe(stream, stream)
+        onIncomingStream: (stream) => {
+          void pipe(stream, stream)
+        }
       })
 
       void pipe(p[0], dialer, p[0])

package/src/stream-muxer/spawner.ts

@@ -13,16 +13,13 @@ export default async (createMuxer: (options?: MuxerOptions) => Promise<Muxer>, n
   const msg = uint8ArrayFromString('simple msg')
 
   const listener = await createMuxer({
-    onStream: async (stream) => {
-      await pipe(
+    onIncomingStream: (stream) => {
+      void pipe(
         stream,
         drain
-      )
-
-      void pipe([], stream)
+      ).then(async () => await pipe([], stream))
     }
   })
-
   const dialer = await createMuxer()
 
   void pipe(listenerSocket, listener, listenerSocket)

package/src/transport/dial-test.ts

@@ -1,26 +1,34 @@
 import { expect } from 'aegir/utils/chai.js'
 import { isValidTick } from '../utils/is-valid-tick.js'
 import { mockUpgrader } from '../mocks/upgrader.js'
-import { goodbye } from 'it-goodbye'
+import { mockRegistrar } from '../mocks/registrar.js'
 import all from 'it-all'
 import { pipe } from 'it-pipe'
 import { AbortError } from '@libp2p/interfaces/errors'
 import sinon from 'sinon'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import drain from 'it-drain'
 import type { TestSetup } from '../index.js'
-import type { Transport, Listener } from '@libp2p/interfaces/transport'
+import type { Transport, Listener, Upgrader } from '@libp2p/interfaces/transport'
 import type { TransportTestFixtures, SetupArgs, Connector } from './index.js'
 import type { Multiaddr } from '@multiformats/multiaddr'
+import type { Registrar } from '@libp2p/interfaces/src/registrar'
 
 export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
   describe('dial', () => {
-    const upgrader = mockUpgrader()
+    let upgrader: Upgrader
+    let registrar: Registrar
     let addrs: Multiaddr[]
     let transport: Transport<any, any>
     let connector: Connector
     let listener: Listener
 
     before(async () => {
+      registrar = mockRegistrar()
+      upgrader = mockUpgrader({
+        registrar
+      });
+
       ({ addrs, transport, connector } = await common.setup({ upgrader }))
     })
 
@@ -40,12 +48,21 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
     })
 
     it('simple', async () => {
+      const protocol = '/hello/1.0.0'
+      void registrar.handle(protocol, (evt) => {
+        void pipe([
+          uint8ArrayFromString('hey')
+        ],
+        evt.detail.stream,
+        drain
+        )
+      })
+
       const upgradeSpy = sinon.spy(upgrader, 'upgradeOutbound')
       const conn = await transport.dial(addrs[0])
-      const { stream } = await conn.newStream(['/hello'])
-      const s = goodbye({ source: [uint8ArrayFromString('hey')], sink: async (source) => await all(source) })
 
-      const result = await pipe(s, stream, s)
+      const { stream } = await conn.newStream([protocol])
+      const result = await all(stream.source)
 
       expect(upgradeSpy.callCount).to.equal(1)
       await expect(upgradeSpy.getCall(0).returnValue).to.eventually.equal(conn)

package/src/transport/listen-test.ts

@@ -13,14 +13,23 @@ import type { Transport } from '@libp2p/interfaces/transport'
 import type { TransportTestFixtures, SetupArgs } from './index.js'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { Connection } from '@libp2p/interfaces/connection'
+import type { Registrar } from '@libp2p/interfaces/src/registrar'
+import { mockRegistrar } from '../mocks/registrar.js'
+import drain from 'it-drain'
 
 export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
   describe('listen', () => {
-    const upgrader = mockUpgrader()
+    let upgrader = mockUpgrader()
     let addrs: Multiaddr[]
     let transport: Transport
+    let registrar: Registrar
 
     before(async () => {
+      registrar = mockRegistrar()
+      upgrader = mockUpgrader({
+        registrar
+      });
+
       ({ transport, addrs } = await common.setup({ upgrader }))
     })
 
@@ -42,6 +51,11 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
       const upgradeSpy = sinon.spy(upgrader, 'upgradeInbound')
       const listenerConns: Connection[] = []
 
+      const protocol = '/test/protocol'
+      void registrar.handle(protocol, (evt) => {
+        void drain(evt.detail.stream.source)
+      })
+
       const listener = transport.createListener({
         handler: (conn) => {
           listenerConns.push(conn)
@@ -60,7 +74,7 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
       // Give the listener a chance to finish its upgrade
       await pWaitFor(() => listenerConns.length === 2)
 
-      const { stream: stream1 } = await conn1.newStream(['/test/protocol'])
+      const { stream: stream1 } = await conn1.newStream([protocol])
 
       // Wait for the data send and close to finish
       await Promise.all([