@libp2p/interface-compliance-tests 1.1.7 → 1.1.11

package/src/mocks/registrar.ts

@@ -1,15 +1,41 @@
-import type { Registrar, StreamHandler } from '@libp2p/interfaces/registrar'
+import type { IncomingStreamData, Registrar, StreamHandler } from '@libp2p/interfaces/registrar'
+import type { Connection } from '@libp2p/interfaces/src/connection'
+import type { PeerId } from '@libp2p/interfaces/src/peer-id'
 import type { Topology } from '@libp2p/interfaces/topology'
+import { connectionPair } from './connection.js'
+import { CustomEvent } from '@libp2p/interfaces'
 
 export class MockRegistrar implements Registrar {
   private readonly topologies: Map<string, { topology: Topology, protocols: string[] }> = new Map()
   private readonly handlers: Map<string, { handler: StreamHandler, protocols: string[] }> = new Map()
 
+  getProtocols () {
+    const protocols = new Set<string>()
+
+    for (const topology of this.topologies.values()) {
+      topology.protocols.forEach(protocol => protocols.add(protocol))
+    }
+
+    for (const handler of this.handlers.values()) {
+      handler.protocols.forEach(protocol => protocols.add(protocol))
+    }
+
+    return Array.from(protocols).sort()
+  }
+
   async handle (protocols: string | string[], handler: StreamHandler) {
     if (!Array.isArray(protocols)) {
       protocols = [protocols]
     }
 
+    for (const protocol of protocols) {
+      for (const { protocols } of this.handlers.values()) {
+        if (protocols.includes(protocol)) {
+          throw new Error(`Handler already registered for protocol ${protocol}`)
+        }
+      }
+    }
+
     const id = `handler-id-${Math.random()}`
 
     this.handlers.set(id, {
@@ -24,16 +50,14 @@ export class MockRegistrar implements Registrar {
     this.handlers.delete(id)
   }
 
-  getHandlers (protocol: string) {
-    const output: StreamHandler[] = []
-
+  getHandler (protocol: string) {
     for (const { handler, protocols } of this.handlers.values()) {
       if (protocols.includes(protocol)) {
-        output.push(handler)
+        return handler
       }
     }
 
-    return output
+    throw new Error(`No handler registered for protocol ${protocol}`)
   }
 
   register (protocols: string | string[], topology: Topology) {
@@ -68,10 +92,44 @@ export class MockRegistrar implements Registrar {
       }
     }
 
-    return output
+    if (output.length > 0) {
+      return output
+    }
+
+    throw new Error(`No topologies registered for protocol ${protocol}`)
   }
 }
 
 export function mockRegistrar () {
   return new MockRegistrar()
 }
+
+export async function mockIncomingStreamEvent (protocol: string, conn: Connection, remotePeer: PeerId): Promise<CustomEvent<IncomingStreamData>> {
+  // @ts-expect-error incomplete implementation
+  return new CustomEvent('incomingStream', {
+    detail: {
+      ...await conn.newStream([protocol]),
+      connection: {
+        remotePeer
+      }
+    }
+  })
+}
+
+export interface Peer {
+  peerId: PeerId
+  registrar: Registrar
+}
+
+export async function connectPeers (protocol: string, a: Peer, b: Peer) {
+  // Notify peers of connection
+  const [aToB, bToA] = connectionPair(a, b)
+
+  for (const topology of a.registrar.getTopologies(protocol)) {
+    await topology.onConnect(b.peerId, aToB)
+  }
+
+  for (const topology of b.registrar.getTopologies(protocol)) {
+    await topology.onConnect(a.peerId, bToA)
+  }
+}

package/src/mocks/upgrader.ts

@@ -18,11 +18,17 @@ export function mockUpgrader (options: MockUpgraderOptions = {}) {
   const upgrader: Upgrader = {
     async upgradeOutbound (multiaddrConnection) {
       ensureProps(multiaddrConnection)
-      return await mockConnection(multiaddrConnection, 'outbound', options.muxer)
+      return mockConnection(multiaddrConnection, {
+        direction: 'outbound',
+        muxer: options.muxer
+      })
     },
     async upgradeInbound (multiaddrConnection) {
       ensureProps(multiaddrConnection)
-      return await mockConnection(multiaddrConnection, 'inbound', options.muxer)
+      return mockConnection(multiaddrConnection, {
+        direction: 'inbound',
+        muxer: options.muxer
+      })
     }
   }
 

package/src/pubsub/api.ts

@@ -3,20 +3,33 @@ import sinon from 'sinon'
 import pDefer from 'p-defer'
 import pWaitFor from 'p-wait-for'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { mockRegistrar } from '../mocks/registrar.js'
+import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+import delay from 'delay'
+import { CustomEvent } from '@libp2p/interfaces'
 import type { TestSetup } from '../index.js'
-import type { PubSub } from '@libp2p/interfaces/pubsub'
+import type { PubSub, PubSubOptions } from '@libp2p/interfaces/pubsub'
 import type { EventMap } from './index.js'
+import type { Registrar } from '@libp2p/interfaces/src/registrar'
+import type { PubsubBaseProtocol } from '@libp2p/pubsub'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
 
-export default (common: TestSetup<PubSub<EventMap>>) => {
+export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>) => {
   describe('pubsub api', () => {
     let pubsub: PubSub<EventMap>
+    let registrar: Registrar
 
     // Create pubsub router
     beforeEach(async () => {
-      pubsub = await common.setup()
+      registrar = mockRegistrar()
+
+      pubsub = await common.setup({
+        peerId: await createEd25519PeerId(),
+        registrar,
+        emitSelf: true
+      })
     })
 
     afterEach(async () => {
@@ -26,22 +39,22 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
     })
 
     it('can start correctly', async () => {
-      sinon.spy(pubsub.registrar, 'register')
+      sinon.spy(registrar, 'register')
 
       await pubsub.start()
 
-      expect(pubsub.started).to.eql(true)
-      expect(pubsub.registrar.register).to.have.property('callCount', 1)
+      expect(pubsub.isStarted()).to.equal(true)
+      expect(registrar.register).to.have.property('callCount', 1)
     })
 
     it('can stop correctly', async () => {
-      sinon.spy(pubsub.registrar, 'unregister')
+      sinon.spy(registrar, 'unregister')
 
       await pubsub.start()
       await pubsub.stop()
 
-      expect(pubsub.started).to.eql(false)
-      expect(pubsub.registrar.unregister).to.have.property('callCount', 1)
+      expect(pubsub.isStarted()).to.equal(false)
+      expect(registrar.unregister).to.have.property('callCount', 1)
     })
 
     it('can subscribe and unsubscribe correctly', async () => {
@@ -50,20 +63,22 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
       }
 
       await pubsub.start()
-      pubsub.subscribe(topic)
-      pubsub.addEventListener('topic', handler)
+      pubsub.addEventListener(topic, handler)
 
       await pWaitFor(() => {
         const topics = pubsub.getTopics()
         return topics.length === 1 && topics[0] === topic
       })
 
-      pubsub.unsubscribe(topic)
+      pubsub.removeEventListener(topic, handler)
 
       await pWaitFor(() => pubsub.getTopics().length === 0)
 
       // Publish to guarantee the handler is not called
-      await pubsub.publish(topic, data)
+      pubsub.dispatchEvent(new CustomEvent(topic, { detail: data }))
+
+      // handlers are called async
+      await delay(100)
 
       await pubsub.stop()
     })
@@ -73,13 +88,12 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
 
       await pubsub.start()
 
-      pubsub.subscribe(topic)
       pubsub.addEventListener(topic, (evt) => {
         const msg = evt.detail
         expect(msg).to.not.eql(undefined)
         defer.resolve()
       })
-      await pubsub.publish(topic, data)
+      pubsub.dispatchEvent(new CustomEvent(topic, { detail: data }))
       await defer.promise
 
       await pubsub.stop()

package/src/pubsub/connection-handlers.ts

@@ -4,28 +4,49 @@ import pDefer from 'p-defer'
 import pWaitFor from 'p-wait-for'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { expectSet } from './utils.js'
+import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+import { connectPeers, mockRegistrar } from '../mocks/registrar.js'
+import { CustomEvent } from '@libp2p/interfaces'
 import type { TestSetup } from '../index.js'
-import type { PubSub, Message } from '@libp2p/interfaces/pubsub'
+import type { Message, PubSubOptions } from '@libp2p/interfaces/pubsub'
 import type { EventMap } from './index.js'
+import type { PeerId } from '@libp2p/interfaces/src/peer-id'
+import type { Registrar } from '@libp2p/interfaces/src/registrar'
+import type { PubsubBaseProtocol } from '@libp2p/pubsub'
 
-export default (common: TestSetup<PubSub<EventMap>>) => {
+export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>) => {
   describe('pubsub connection handlers', () => {
-    let psA: PubSub<EventMap>
-    let psB: PubSub<EventMap>
+    let psA: PubsubBaseProtocol<EventMap>
+    let psB: PubsubBaseProtocol<EventMap>
+    let peerA: PeerId
+    let peerB: PeerId
+    let registrarA: Registrar
+    let registrarB: Registrar
 
     describe('nodes send state on connection', () => {
       // Create pubsub nodes and connect them
       before(async () => {
-        psA = await common.setup()
-        psB = await common.setup()
+        peerA = await createEd25519PeerId()
+        peerB = await createEd25519PeerId()
 
-        expect(psA.peers.size).to.be.eql(0)
-        expect(psB.peers.size).to.be.eql(0)
+        registrarA = mockRegistrar()
+        registrarB = mockRegistrar()
+
+        psA = await common.setup({
+          peerId: peerA,
+          registrar: registrarA
+        })
+        psB = await common.setup({
+          peerId: peerB,
+          registrar: registrarB
+        })
 
         // Start pubsub
         await psA.start()
         await psB.start()
+
+        expect(psA.getPeers()).to.be.empty()
+        expect(psB.getPeers()).to.be.empty()
       })
 
       // Make subscriptions prior to nodes connected
@@ -33,10 +54,10 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
         psA.subscribe('Za')
         psB.subscribe('Zb')
 
-        expect(psA.peers.size).to.equal(0)
-        expectSet(psA.subscriptions, ['Za'])
-        expect(psB.peers.size).to.equal(0)
-        expectSet(psB.subscriptions, ['Zb'])
+        expect(psA.getPeers()).to.be.empty()
+        expect(psA.getTopics()).to.deep.equal(['Za'])
+        expect(psB.getPeers()).to.be.empty()
+        expect(psB.getTopics()).to.deep.equal(['Zb'])
       })
 
       after(async () => {
@@ -45,9 +66,7 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
       })
 
       it('existing subscriptions are sent upon peer connection', async function () {
-        await Promise.all([
-          // @ts-expect-error protected fields
-          psA._libp2p.dial(psB.peerId),
+        const subscriptionsChanged = Promise.all([
           new Promise((resolve) => psA.addEventListener('pubsub:subscription-change', resolve, {
             once: true
           })),
@@ -56,24 +75,51 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
           }))
         ])
 
-        expect(psA.peers.size).to.equal(1)
-        expect(psB.peers.size).to.equal(1)
+        await connectPeers(psA.multicodecs[0], {
+          peerId: peerA,
+          registrar: registrarA
+        }, {
+          peerId: peerB,
+          registrar: registrarB
+        })
 
-        expectSet(psA.subscriptions, ['Za'])
+        await subscriptionsChanged
 
-        expectSet(psB.topics.get('Za'), [psA.peerId.toString()])
+        expect(psA.getPeers()).to.have.lengthOf(1)
+        expect(psB.getPeers()).to.have.lengthOf(1)
 
-        expectSet(psB.subscriptions, ['Zb'])
+        expect(psA.getTopics()).to.deep.equal(['Za'])
+        expect(psB.getTopics()).to.deep.equal(['Zb'])
 
-        expectSet(psA.topics.get('Zb'), [psB.peerId.toString()])
+        expect(psA.getSubscribers('Zb').map(p => p.toString())).to.deep.equal([peerB.toString()])
+        expect(psB.getSubscribers('Za').map(p => p.toString())).to.deep.equal([peerA.toString()])
       })
     })
 
     describe('pubsub started before connect', () => {
+      let psA: PubsubBaseProtocol<EventMap>
+      let psB: PubsubBaseProtocol<EventMap>
+      let peerA: PeerId
+      let peerB: PeerId
+      let registrarA: Registrar
+      let registrarB: Registrar
+
       // Create pubsub nodes and start them
       beforeEach(async () => {
-        psA = await common.setup()
-        psB = await common.setup()
+        peerA = await createEd25519PeerId()
+        peerB = await createEd25519PeerId()
+
+        registrarA = mockRegistrar()
+        registrarB = mockRegistrar()
+
+        psA = await common.setup({
+          peerId: peerA,
+          registrar: registrarA
+        })
+        psB = await common.setup({
+          peerId: peerB,
+          registrar: registrarB
+        })
 
         await psA.start()
         await psB.start()
@@ -86,13 +132,17 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
       })
 
       it('should get notified of connected peers on dial', async () => {
-        // @ts-expect-error protected fields
-        const connection = await psA._libp2p.dial(psB.peerId)
-        expect(connection).to.exist()
+        await connectPeers(psA.multicodecs[0], {
+          peerId: peerA,
+          registrar: registrarA
+        }, {
+          peerId: peerB,
+          registrar: registrarB
+        })
 
         return await Promise.all([
-          pWaitFor(() => psA.peers.size === 1),
-          pWaitFor(() => psB.peers.size === 1)
+          pWaitFor(() => psA.getPeers().length === 1),
+          pWaitFor(() => psB.getPeers().length === 1)
         ])
       })
 
@@ -101,8 +151,13 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
         const topic = 'test-topic'
         const data = uint8ArrayFromString('hey!')
 
-        // @ts-expect-error protected fields
-        await psA._libp2p.dial(psB.peerId)
+        await connectPeers(psA.multicodecs[0], {
+          peerId: peerA,
+          registrar: registrarA
+        }, {
+          peerId: peerB,
+          registrar: registrarB
+        })
 
         let subscribedTopics = psA.getTopics()
         expect(subscribedTopics).to.not.include(topic)
@@ -120,19 +175,38 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
         // wait for psB to know about psA subscription
         await pWaitFor(() => {
           const subscribedPeers = psB.getSubscribers(topic)
-          return subscribedPeers.includes(psA.peerId.toString())
+          return subscribedPeers.map(p => p.toString()).includes(peerA.toString())
         })
-        void psB.publish(topic, data)
+        void psB.dispatchEvent(new CustomEvent(topic, { detail: data }))
 
         await defer.promise
       })
     })
 
     describe('pubsub started after connect', () => {
+      let psA: PubsubBaseProtocol<EventMap>
+      let psB: PubsubBaseProtocol<EventMap>
+      let peerA: PeerId
+      let peerB: PeerId
+      let registrarA: Registrar
+      let registrarB: Registrar
+
       // Create pubsub nodes
       beforeEach(async () => {
-        psA = await common.setup()
-        psB = await common.setup()
+        peerA = await createEd25519PeerId()
+        peerB = await createEd25519PeerId()
+
+        registrarA = mockRegistrar()
+        registrarB = mockRegistrar()
+
+        psA = await common.setup({
+          peerId: peerA,
+          registrar: registrarA
+        })
+        psB = await common.setup({
+          peerId: peerB,
+          registrar: registrarB
+        })
       })
 
       afterEach(async () => {
@@ -145,18 +219,20 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
       })
 
       it('should get notified of connected peers after starting', async () => {
-        // @ts-expect-error protected fields
-        const connection = await psA._libp2p.dial(psB.peerId)
-        expect(connection).to.exist()
-        expect(psA.peers.size).to.be.eql(0)
-        expect(psB.peers.size).to.be.eql(0)
-
         await psA.start()
         await psB.start()
 
+        await connectPeers(psA.multicodecs[0], {
+          peerId: peerA,
+          registrar: registrarA
+        }, {
+          peerId: peerB,
+          registrar: registrarB
+        })
+
         return await Promise.all([
-          pWaitFor(() => psA.peers.size === 1),
-          pWaitFor(() => psB.peers.size === 1)
+          pWaitFor(() => psA.getPeers().length === 1),
+          pWaitFor(() => psB.getPeers().length === 1)
         ])
       })
 
@@ -165,15 +241,20 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
         const topic = 'test-topic'
         const data = uint8ArrayFromString('hey!')
 
-        // @ts-expect-error protected fields
-        await psA._libp2p.dial(psB.peerId)
-
         await psA.start()
         await psB.start()
 
+        await connectPeers(psA.multicodecs[0], {
+          peerId: peerA,
+          registrar: registrarA
+        }, {
+          peerId: peerB,
+          registrar: registrarB
+        })
+
         await Promise.all([
-          pWaitFor(() => psA.peers.size === 1),
-          pWaitFor(() => psB.peers.size === 1)
+          pWaitFor(() => psA.getPeers().length === 1),
+          pWaitFor(() => psB.getPeers().length === 1)
         ])
 
         let subscribedTopics = psA.getTopics()
@@ -192,19 +273,38 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
         // wait for psB to know about psA subscription
         await pWaitFor(() => {
           const subscribedPeers = psB.getSubscribers(topic)
-          return subscribedPeers.includes(psA.peerId.toString())
+          return subscribedPeers.map(p => p.toString()).includes(peerA.toString())
         })
-        void psB.publish(topic, data)
+        void psB.dispatchEvent(new CustomEvent(topic, { detail: data }))
 
         await defer.promise
       })
     })
 
     describe('pubsub with intermittent connections', () => {
+      let psA: PubsubBaseProtocol<EventMap>
+      let psB: PubsubBaseProtocol<EventMap>
+      let peerA: PeerId
+      let peerB: PeerId
+      let registrarA: Registrar
+      let registrarB: Registrar
+
       // Create pubsub nodes and start them
       beforeEach(async () => {
-        psA = await common.setup()
-        psB = await common.setup()
+        peerA = await createEd25519PeerId()
+        peerB = await createEd25519PeerId()
+
+        registrarA = mockRegistrar()
+        registrarB = mockRegistrar()
+
+        psA = await common.setup({
+          peerId: peerA,
+          registrar: registrarA
+        })
+        psB = await common.setup({
+          peerId: peerB,
+          registrar: registrarB
+        })
 
         await psA.start()
         await psB.start()
@@ -219,17 +319,21 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
         await common.teardown()
       })
 
-      it('should receive pubsub messages after a node restart', async function () {
+      it.skip('should receive pubsub messages after a node restart', async function () {
         const topic = 'test-topic'
         const data = uint8ArrayFromString('hey!')
-        const psAid = psA.peerId.toString()
 
         let counter = 0
         const defer1 = pDefer()
         const defer2 = pDefer()
 
-        // @ts-expect-error protected fields
-        await psA._libp2p.dial(psB.peerId)
+        await connectPeers(psA.multicodecs[0], {
+          peerId: peerA,
+          registrar: registrarA
+        }, {
+          peerId: peerB,
+          registrar: registrarB
+        })
 
         let subscribedTopics = psA.getTopics()
         expect(subscribedTopics).to.not.include(topic)
@@ -248,9 +352,9 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
         // wait for psB to know about psA subscription
         await pWaitFor(() => {
           const subscribedPeers = psB.getSubscribers(topic)
-          return subscribedPeers.includes(psAid)
+          return subscribedPeers.map(p => p.toString()).includes(peerA.toString())
         })
-        void psB.publish(topic, data)
+        void psB.dispatchEvent(new CustomEvent(topic, { detail: data }))
 
         await defer1.promise
 
@@ -269,23 +373,26 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
         await psB._libp2p.start()
         await psB.start()
 
-        // @ts-expect-error protected fields
-        psA._libp2p.peerStore.addressBook.set(psB.peerId, psB._libp2p.multiaddrs)
-        // @ts-expect-error protected fields
-        await psA._libp2p.dial(psB.peerId)
+        await connectPeers(psA.multicodecs[0], {
+          peerId: peerA,
+          registrar: registrarA
+        }, {
+          peerId: peerB,
+          registrar: registrarB
+        })
 
         // wait for remoteLibp2p to know about libp2p subscription
         await pWaitFor(() => {
           const subscribedPeers = psB.getSubscribers(topic)
-          return subscribedPeers.includes(psAid)
+          return subscribedPeers.toString().includes(peerA.toString())
         })
 
-        void psB.publish(topic, data)
+        void psB.dispatchEvent(new CustomEvent(topic, { detail: data }))
 
         await defer2.promise
       })
 
-      it('should handle quick reconnects with a delayed disconnect', async () => {
+      it.skip('should handle quick reconnects with a delayed disconnect', async () => {
         // Subscribe on both
         let aReceivedFirstMessageFromB = false
         let aReceivedSecondMessageFromB = false
@@ -327,21 +434,25 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
         // Create two connections to the remote peer
         // @ts-expect-error protected fields
         const originalConnection = await psA._libp2p.dialer.connectToPeer(psB.peerId)
+
         // second connection
-        // @ts-expect-error protected fields
-        await psA._libp2p.dialer.connectToPeer(psB.peerId)
-        // @ts-expect-error protected fields
-        expect(psA._libp2p.connections.get(psB.peerId.toString())).to.have.length(2)
+        await connectPeers(psA.multicodecs[0], {
+          peerId: peerA,
+          registrar: registrarA
+        }, {
+          peerId: peerB,
+          registrar: registrarB
+        })
 
         // Wait for subscriptions to occur
         await pWaitFor(() => {
-          return psA.getSubscribers(topic).includes(psB.peerId.toString()) &&
-            psB.getSubscribers(topic).includes(psA.peerId.toString())
+          return psA.getSubscribers(topic).includes(peerB) &&
+            psB.getSubscribers(topic).map(p => p.toString()).includes(peerA.toString())
         })
 
         // Verify messages go both ways
-        void psA.publish(topic, uint8ArrayFromString('message-from-a-1'))
-        void psB.publish(topic, uint8ArrayFromString('message-from-b-1'))
+        void psA.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('message-from-a-1') }))
+        void psB.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('message-from-b-1') }))
         await pWaitFor(() => {
           return aReceivedFirstMessageFromB && bReceivedFirstMessageFromA
         })
@@ -354,8 +465,8 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
         await pWaitFor(() => psAConnUpdateSpy.callCount === 1)
 
         // Verify messages go both ways after the disconnect
-        void psA.publish(topic, uint8ArrayFromString('message-from-a-2'))
-        void psB.publish(topic, uint8ArrayFromString('message-from-b-2'))
+        void psA.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('message-from-a-2') }))
+        void psB.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('message-from-b-2') }))
         await pWaitFor(() => {
           return aReceivedSecondMessageFromB && bReceivedSecondMessageFromA
         })