@libp2p/interface-compliance-tests 1.0.7 → 1.1.2

package/src/pubsub/two-nodes.ts

@@ -11,7 +11,7 @@ import {
   first,
   expectSet
 } from './utils.js'
-import type { Startable } from '@libp2p/interfaces'
+import type { EventMap } from './index.js'
 
 const topic = 'foo'
 
@@ -19,10 +19,10 @@ function shouldNotHappen () {
   expect.fail()
 }
 
-export default (common: TestSetup<PubSub & Startable>) => {
+export default (common: TestSetup<PubSub<EventMap>>) => {
   describe('pubsub with two nodes', () => {
-    let psA: PubSub & Startable
-    let psB: PubSub & Startable
+    let psA: PubSub<EventMap>
+    let psB: PubSub<EventMap>
 
     // Create pubsub nodes and connect them
     before(async () => {
@@ -55,7 +55,8 @@ export default (common: TestSetup<PubSub & Startable>) => {
     it('Subscribe to a topic in nodeA', async () => {
       const defer = pDefer()
 
-      psB.once('pubsub:subscription-change', ({ peerId: changedPeerId, subscriptions: changedSubs }) => {
+      psB.addEventListener('pubsub:subscription-change', (evt) => {
+        const { peerId: changedPeerId, subscriptions: changedSubs } = evt.detail
         expectSet(psA.subscriptions, [topic])
         expect(psB.peers.size).to.equal(1)
         expectSet(psB.topics.get(topic), [psA.peerId.toString()])
@@ -64,6 +65,8 @@ export default (common: TestSetup<PubSub & Startable>) => {
         expect(changedSubs[0].topicID).to.equal(topic)
         expect(changedSubs[0].subscribe).to.equal(true)
         defer.resolve()
+      }, {
+        once: true
       })
       psA.subscribe(topic)
 
@@ -73,13 +76,18 @@ export default (common: TestSetup<PubSub & Startable>) => {
     it('Publish to a topic in nodeA', async () => {
       const defer = pDefer()
 
-      psA.once(topic, (msg) => {
+      psA.addEventListener(topic, (evt) => {
+        const msg = evt.detail
         expect(uint8ArrayToString(msg.data)).to.equal('hey')
-        psB.removeListener(topic, shouldNotHappen)
+        psB.removeEventListener(topic, shouldNotHappen)
         defer.resolve()
+      }, {
+        once: true
       })
 
-      psB.once(topic, shouldNotHappen)
+      psB.addEventListener(topic, shouldNotHappen, {
+        once: true
+      })
 
       void psA.publish(topic, uint8ArrayFromString('hey'))
 
@@ -89,19 +97,26 @@ export default (common: TestSetup<PubSub & Startable>) => {
     it('Publish to a topic in nodeB', async () => {
       const defer = pDefer()
 
-      psA.once(topic, (msg) => {
-        psA.once(topic, shouldNotHappen)
+      psA.addEventListener(topic, (evt) => {
+        const msg = evt.detail
+        psA.addEventListener(topic, shouldNotHappen, {
+          once: true
+        })
         expect(uint8ArrayToString(msg.data)).to.equal('banana')
 
         setTimeout(() => {
-          psA.removeListener(topic, shouldNotHappen)
-          psB.removeListener(topic, shouldNotHappen)
+          psA.removeEventListener(topic, shouldNotHappen)
+          psB.removeEventListener(topic, shouldNotHappen)
 
           defer.resolve()
         }, 100)
+      }, {
+        once: true
       })
 
-      psB.once(topic, shouldNotHappen)
+      psB.addEventListener(topic, shouldNotHappen, {
+        once: true
+      })
 
       void psB.publish(topic, uint8ArrayFromString('banana'))
 
@@ -112,18 +127,21 @@ export default (common: TestSetup<PubSub & Startable>) => {
       const defer = pDefer()
       let counter = 0
 
-      psB.once(topic, shouldNotHappen)
-      psA.on(topic, receivedMsg)
+      psB.addEventListener(topic, shouldNotHappen, {
+        once: true
+      })
+      psA.addEventListener(topic, receivedMsg)
 
-      function receivedMsg (msg: Message) {
+      function receivedMsg (evt: CustomEvent<Message>) {
+        const msg = evt.detail
         expect(uint8ArrayToString(msg.data)).to.equal('banana')
         expect(msg.from).to.be.eql(psB.peerId.toString())
         expect(msg.seqno).to.be.a('Uint8Array')
         expect(msg.topicIDs).to.be.eql([topic])
 
         if (++counter === 10) {
-          psA.removeListener(topic, receivedMsg)
-          psB.removeListener(topic, shouldNotHappen)
+          psA.removeEventListener(topic, receivedMsg)
+          psB.removeEventListener(topic, shouldNotHappen)
 
           defer.resolve()
         }
@@ -140,7 +158,8 @@ export default (common: TestSetup<PubSub & Startable>) => {
       psA.unsubscribe(topic)
       expect(psA.subscriptions.size).to.equal(0)
 
-      psB.once('pubsub:subscription-change', ({ peerId: changedPeerId, subscriptions: changedSubs }) => {
+      psB.addEventListener('pubsub:subscription-change', (evt) => {
+        const { peerId: changedPeerId, subscriptions: changedSubs } = evt.detail
         expect(psB.peers.size).to.equal(1)
         expectSet(psB.topics.get(topic), [])
         expect(changedPeerId.toString()).to.equal(first(psB.peers).id.toString())
@@ -149,6 +168,8 @@ export default (common: TestSetup<PubSub & Startable>) => {
         expect(changedSubs[0].subscribe).to.equal(false)
 
         defer.resolve()
+      }, {
+        once: true
       })
 
       return await defer.promise
@@ -157,12 +178,16 @@ export default (common: TestSetup<PubSub & Startable>) => {
     it('Publish to a topic:Z in nodeA nodeB', async () => {
       const defer = pDefer()
 
-      psA.once('Z', shouldNotHappen)
-      psB.once('Z', shouldNotHappen)
+      psA.addEventListener('Z', shouldNotHappen, {
+        once: true
+      })
+      psB.addEventListener('Z', shouldNotHappen, {
+        once: true
+      })
 
       setTimeout(() => {
-        psA.removeListener('Z', shouldNotHappen)
-        psB.removeListener('Z', shouldNotHappen)
+        psA.removeEventListener('Z', shouldNotHappen)
+        psB.removeEventListener('Z', shouldNotHappen)
         defer.resolve()
       }, 100)
 

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

@@ -10,10 +10,11 @@ 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 type { Source } from 'it-stream-types'
+import type { Stream } from '@libp2p/interfaces/connection'
+import type { Muxer, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
+import type { Source, Duplex } from 'it-stream-types'
 
-async function close (stream: MuxedStream) {
+async function drainAndClose (stream: Duplex<Uint8Array>) {
   return await pipe([], stream, drain)
 }
 
@@ -22,8 +23,8 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
     it('Open a stream from the dialer', async () => {
       const p = duplexPair<Uint8Array>()
       const dialer = await common.setup()
-      const onStreamPromise: DeferredPromise<MuxedStream> = defer()
-      const onStreamEndPromise: DeferredPromise<MuxedStream> = defer()
+      const onStreamPromise: DeferredPromise<Stream> = defer()
+      const onStreamEndPromise: DeferredPromise<Stream> = defer()
 
       const listener = await common.setup({
         onStream: stream => {
@@ -34,18 +35,21 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
         }
       })
 
-      void pipe(p[0], dialer.newStream('/test/stream'), p[0])
-      void pipe(p[1], listener.newStream('/test/stream'), p[1])
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
 
       const conn = dialer.newStream()
       expect(dialer.streams).to.include(conn)
       expect(isValidTick(conn.timeline.open)).to.equal(true)
 
+      void drainAndClose(conn)
+
       const stream = await onStreamPromise.promise
       expect(isValidTick(stream.timeline.open)).to.equal(true)
       // Make sure the stream is being tracked
       expect(listener.streams).to.include(stream)
-      void close(stream)
+
+      void drainAndClose(stream)
 
       // Make sure stream is closed properly
       const endedStream = await onStreamEndPromise.promise
@@ -58,7 +62,8 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
       // Make sure the stream is removed from tracking
       expect(isValidTick(endedStream.timeline.close)).to.equal(true)
 
-      await close(conn)
+      await drainAndClose(dialer)
+      await drainAndClose(listener)
 
       // ensure we have no streams left
       expect(dialer.streams).to.have.length(0)
@@ -67,7 +72,7 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
 
     it('Open a stream from the listener', async () => {
       const p = duplexPair<Uint8Array>()
-      const onStreamPromise: DeferredPromise<MuxedStream> = defer()
+      const onStreamPromise: DeferredPromise<Stream> = defer()
       const dialer = await common.setup({
         onStream: stream => {
           onStreamPromise.resolve(stream)
@@ -76,24 +81,27 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
 
       const listener = await common.setup()
 
-      void pipe(p[0], dialer.newStream('/test/stream'), p[0])
-      void pipe(p[1], listener.newStream('/test/stream'), p[1])
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
 
       const conn = listener.newStream()
 
+      void drainAndClose(conn)
+
       const stream = await onStreamPromise.promise
       expect(isValidTick(stream.timeline.open)).to.equal(true)
       expect(listener.streams).to.include(conn)
       expect(isValidTick(conn.timeline.open)).to.equal(true)
-      await close(stream)
+      void drainAndClose(stream)
 
-      await close(conn)
+      await drainAndClose(dialer)
+      await drainAndClose(listener)
     })
 
     it('Open a stream on both sides', async () => {
       const p = duplexPair<Uint8Array>()
-      const onDialerStreamPromise: DeferredPromise<MuxedStream> = defer()
-      const onListenerStreamPromise: DeferredPromise<MuxedStream> = defer()
+      const onDialerStreamPromise: DeferredPromise<Stream> = defer()
+      const onListenerStreamPromise: DeferredPromise<Stream> = defer()
       const dialer = await common.setup({
         onStream: stream => {
           onDialerStreamPromise.resolve(stream)
@@ -105,27 +113,30 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
         }
       })
 
-      void pipe(p[0], dialer.newStream('/test/stream'), p[0])
-      void pipe(p[1], listener.newStream('/test/stream'), p[1])
+      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 dialerStream = await onDialerStreamPromise.promise
       const listenerStream = await onListenerStreamPromise.promise
 
-      await close(dialerStream)
-      await close(listenerStream)
+      await drainAndClose(dialerStream)
+      await drainAndClose(listenerStream)
 
-      await close(dialerConn)
-      await close(listenerConn)
+      await drainAndClose(dialer)
+      await drainAndClose(listener)
     })
 
     it('Open a stream on one side, write, open a stream on the other side', async () => {
       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 onDialerStreamPromise: DeferredPromise<Stream> = defer()
+      const onListenerStreamPromise: DeferredPromise<Stream> = defer()
       const dialer = await common.setup({
         onStream: stream => {
           onDialerStreamPromise.resolve(stream)
@@ -137,8 +148,8 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
         }
       })
 
-      void pipe(p[0], dialer.newStream('/test/stream'), p[0])
-      void pipe(p[1], listener.newStream('/test/stream'), p[1])
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
 
       const dialerConn = dialer.newStream()
       const listenerConn = listener.newStream()

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

@@ -4,9 +4,10 @@ import { duplexPair } from 'it-pair/duplex'
 import { abortableSource, abortableDuplex } from 'abortable-iterator'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import drain from 'it-drain'
+import { mockUpgrader, mockMultiaddrConnection } from '../transport/utils/index.js'
 import type { TestSetup } from '../index.js'
 import type { Muxer, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
-import type { Connection } from '@libp2p/interfaces/connection'
+import { expect } from 'aegir/utils/chai.js'
 
 async function pause (ms: number) {
   return await new Promise(resolve => setTimeout(resolve, ms))
@@ -27,30 +28,13 @@ const infiniteRandom = {
 
 export default (common: TestSetup<Muxer, MuxerOptions>) => {
   describe('close', () => {
-    it('closing underlying socket closes streams (tcp)', async () => {
-      const mockConn = (muxer: Muxer): Connection => {
-        // @ts-expect-error not all Connection methods are implemented
-        const connection: Connection = {
-          newStream: async (multicodecs) => {
-            return {
-              protocol: multicodecs[0],
-              stream: muxer.newStream(`${multicodecs[0]}`)
-            }
-          }
+    it('closing underlying socket closes streams', async () => {
+      const muxer = await common.setup({
+        onStream: (stream) => {
+          void pipe(stream, stream)
         }
-
-        return connection
-      }
-
-      const mockUpgrade = async (maConn: any) => {
-        const muxer = await common.setup({
-          onStream: (stream) => {
-            void pipe(stream, stream)
-          }
-        })
-        pipe(maConn, muxer.newStream('/test/stream'), maConn)
-        return mockConn(muxer)
-      }
+      })
+      const upgrader = mockUpgrader({ muxer })
 
       const [local, remote] = duplexPair<Uint8Array>()
       const controller = new AbortController()
@@ -58,8 +42,8 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
         returnOnAbort: true
       })
 
-      await mockUpgrade(abortableRemote)
-      const dialerConn = await mockUpgrade(local)
+      await upgrader.upgradeInbound(mockMultiaddrConnection(abortableRemote))
+      const dialerConn = await upgrader.upgradeOutbound(mockMultiaddrConnection(local))
 
       const s1 = await dialerConn.newStream([''])
       const s2 = await dialerConn.newStream([''])
@@ -73,6 +57,8 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
       // test is complete when all muxed streams have closed
       await s1Result
       await s2Result
+
+      expect(muxer.streams).to.be.empty()
     })
 
     it('closing one of the muxed streams doesn\'t close others', async () => {
@@ -84,8 +70,8 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
         onStream: async (stream) => await pipe(stream, stream)
       })
 
-      void pipe(p[0], dialer.newStream('/test/stream'), p[0])
-      void pipe(p[1], listener.newStream('/test/stream'), p[1])
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
 
       const stream = dialer.newStream()
       const streams = Array.from(Array(5), () => dialer.newStream())

package/src/stream-muxer/index.ts

@@ -3,9 +3,9 @@ import closeTest from './close-test.js'
 import stressTest from './stress-test.js'
 import megaStressTest from './mega-stress-test.js'
 import type { TestSetup } from '../index.js'
-import type { Muxer } from '@libp2p/interfaces/stream-muxer'
+import type { Muxer, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
 
-export default (common: TestSetup<Muxer>) => {
+export default (common: TestSetup<Muxer, MuxerOptions>) => {
   describe('interface-stream-muxer', () => {
     baseTest(common)
     closeTest(common)

package/src/stream-muxer/mega-stress-test.ts

@@ -1,4 +1,4 @@
-import spawn from './spawner'
+import spawn from './spawner.js'
 import type { TestSetup } from '../index.js'
 import type { Muxer, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
 

package/src/stream-muxer/spawner.ts

@@ -25,8 +25,8 @@ export default async (createMuxer: (options?: MuxerOptions) => Promise<Muxer>, n
 
   const dialer = await createMuxer()
 
-  void pipe(listenerSocket, listener.newStream('/test/stream'), listenerSocket)
-  void pipe(dialerSocket, dialer.newStream('/test/stream'), dialerSocket)
+  void pipe(listenerSocket, listener, listenerSocket)
+  void pipe(dialerSocket, dialer, dialerSocket)
 
   const spawnStream = async () => {
     const stream = dialer.newStream()

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

@@ -1,4 +1,4 @@
-import spawn from './spawner'
+import spawn from './spawner.js'
 import type { TestSetup } from '../index.js'
 import type { Muxer, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
 

package/src/transport/listen-test.ts

@@ -6,6 +6,7 @@ import { pipe } from 'it-pipe'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { isValidTick, mockUpgrader } from './utils/index.js'
 import defer from 'p-defer'
+import { CustomEvent } from '@libp2p/interfaces'
 import type { TestSetup } from '../index.js'
 import type { Transport } from '@libp2p/interfaces/transport'
 import type { TransportTestFixtures, SetupArgs } from './index.js'
@@ -108,8 +109,8 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
         const deferred = defer()
         let conn
 
-        listener.on('connection', (c) => {
-          conn = c
+        listener.addEventListener('connection', (evt) => {
+          conn = evt.detail
           deferred.resolve()
         })
 
@@ -127,7 +128,7 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
 
       it('listening', (done) => {
         const listener = transport.createListener()
-        listener.on('listening', () => {
+        listener.addEventListener('listening', () => {
           listener.close().then(done, done)
         })
         void listener.listen(addrs[0])
@@ -135,16 +136,18 @@ export default (common: TestSetup<TransportTestFixtures, SetupArgs>) => {
 
       it('error', (done) => {
         const listener = transport.createListener()
-        listener.on('error', (err) => {
-          expect(err).to.exist()
+        listener.addEventListener('error', (evt) => {
+          expect(evt.detail).to.be.an.instanceOf(Error)
           listener.close().then(done, done)
         })
-        listener.emit('error', new Error('my err'))
+        listener.dispatchEvent(new CustomEvent('error', {
+          detail: new Error('my err')
+        }))
       })
 
       it('close', (done) => {
         const listener = transport.createListener()
-        listener.on('close', done)
+        listener.addEventListener('close', () => done())
 
         void (async () => {
           await listener.listen(addrs[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,7 +29,64 @@ 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', 'timeline', 'close'].forEach(prop => {
       expect(multiaddrConnection).to.have.property(prop)
@@ -31,30 +94,37 @@ export function mockUpgrader () {
     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> {
+async function createConnection (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 PeerIdFactory.createEd25519PeerId()
 
-  const streams: MuxedStream[] = []
+  const streams: Stream[] = []
   let streamId = 0
 
   const registry = new Map()
 
+  void pipe(
+    maConn, muxer, maConn
+  )
+
   return {
     id: 'mock-connection',
     remoteAddr,
@@ -70,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
       }
@@ -98,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)
+  }
+}