@libp2p/interface-compliance-tests 1.1.4 → 1.1.8

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) {
@@ -62,10 +86,48 @@ export class MockRegistrar implements Registrar {
   getTopologies (protocol: string) {
     const output: Topology[] = []
 
-    return output
+    for (const { topology, protocols } of this.topologies.values()) {
+      if (protocols.includes(protocol)) {
+        output.push(topology)
+      }
+    }
+
+    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 async function connectPeers (protocol: string, registrarA: Registrar, registrarB: Registrar, peerIdA: PeerId, peerIdB: PeerId) {
+  const topologyA = registrarA.getTopologies(protocol)[0]
+  const topologyB = registrarB.getTopologies(protocol)[0]
+  // const handlerA = registrarA.getHandler(protocol)
+  // const handlerB = registrarB.getHandler(protocol)
+
+  // Notify peers of connection
+  const [bToA, aToB] = connectionPair(peerIdA, peerIdB)
+
+  await topologyA.onConnect(peerIdB, aToB)
+  // await handlerA(await mockIncomingStreamEvent(protocol, aToB, peerIdB))
+
+  await topologyB.onConnect(peerIdA, bToA)
+  // await handlerB(await mockIncomingStreamEvent(protocol, bToA, peerIdA))
+}

package/src/mocks/upgrader.ts

@@ -1,5 +1,4 @@
 import { expect } from 'aegir/utils/chai.js'
-import { mockMuxer } from './muxer.js'
 import { mockConnection } from './connection.js'
 import type { Upgrader, MultiaddrConnection } from '@libp2p/interfaces/transport'
 import type { Muxer } from '@libp2p/interfaces/stream-muxer'
@@ -16,16 +15,20 @@ export function mockUpgrader (options: MockUpgraderOptions = {}) {
     return multiaddrConnection
   }
 
-  const muxer = options.muxer ?? mockMuxer()
-
   const upgrader: Upgrader = {
     async upgradeOutbound (multiaddrConnection) {
       ensureProps(multiaddrConnection)
-      return await mockConnection(multiaddrConnection, 'outbound', muxer)
+      return mockConnection(multiaddrConnection, {
+        direction: 'outbound',
+        muxer: options.muxer
+      })
     },
     async upgradeInbound (multiaddrConnection) {
       ensureProps(multiaddrConnection)
-      return await mockConnection(multiaddrConnection, 'inbound', muxer)
+      return mockConnection(multiaddrConnection, {
+        direction: 'inbound',
+        muxer: options.muxer
+      })
     }
   }
 

package/src/pubsub/api.ts

@@ -4,19 +4,29 @@ import pDefer from 'p-defer'
 import pWaitFor from 'p-wait-for'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 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 { mockRegistrar } from '../mocks/registrar.js'
+import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
 
-export default (common: TestSetup<PubSub<EventMap>>) => {
+export default (common: TestSetup<PubSub<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 +36,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 () => {

package/src/pubsub/connection-handlers.ts

@@ -4,28 +4,47 @@ 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 type { TestSetup } from '../index.js'
-import type { PubSub, Message } from '@libp2p/interfaces/pubsub'
+import type { PubSub, Message, PubSubOptions } from '@libp2p/interfaces/pubsub'
 import type { EventMap } from './index.js'
+import type { PeerId } from '@libp2p/interfaces/src/peer-id'
+import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+import type { Registrar } from '@libp2p/interfaces/src/registrar'
+import { connectPeers, mockRegistrar } from '../mocks/registrar.js'
 
-export default (common: TestSetup<PubSub<EventMap>>) => {
+export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
   describe('pubsub connection handlers', () => {
     let psA: PubSub<EventMap>
     let psB: PubSub<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()
+
+        registrarA = mockRegistrar()
+        registrarB = mockRegistrar()
 
-        expect(psA.peers.size).to.be.eql(0)
-        expect(psB.peers.size).to.be.eql(0)
+        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 +52,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 +64,9 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
       })
 
       it('existing subscriptions are sent upon peer connection', async function () {
+        await connectPeers(psA.multicodecs[0], registrarA, registrarB, peerA, peerB)
+
         await Promise.all([
-          // @ts-expect-error protected fields
-          psA._libp2p.dial(psB.peerId),
           new Promise((resolve) => psA.addEventListener('pubsub:subscription-change', resolve, {
             once: true
           })),
@@ -56,16 +75,14 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
           }))
         ])
 
-        expect(psA.peers.size).to.equal(1)
-        expect(psB.peers.size).to.equal(1)
-
-        expectSet(psA.subscriptions, ['Za'])
+        expect(psA.getPeers()).to.have.lengthOf(1)
+        expect(psB.getPeers()).to.have.lengthOf(1)
 
-        expectSet(psB.topics.get('Za'), [psA.peerId.toString()])
+        expect(psA.getTopics()).to.deep.equal(['Za'])
+        expect(psB.getTopics()).to.deep.equal(['Zb'])
 
-        expectSet(psB.subscriptions, ['Zb'])
-
-        expectSet(psA.topics.get('Zb'), [psB.peerId.toString()])
+        expect(psA.getSubscribers('Zb')).to.deep.equal([peerB])
+        expect(psB.getSubscribers('Za')).to.deep.equal([peerA])
       })
     })
 
@@ -86,13 +103,11 @@ 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], registrarA, registrarB, peerA, peerB)
 
         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 +116,7 @@ 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], registrarA, registrarB, peerA, peerB)
 
         let subscribedTopics = psA.getTopics()
         expect(subscribedTopics).to.not.include(topic)
@@ -120,7 +134,7 @@ 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.includes(peerA)
         })
         void psB.publish(topic, data)
 
@@ -148,15 +162,15 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
         // @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)
+        expect(psA.getPeers()).to.be.empty()
+        expect(psB.getPeers()).to.be.empty()
 
         await psA.start()
         await psB.start()
 
         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 +179,14 @@ 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], registrarA, registrarB, peerA, peerB)
 
         await psA.start()
         await psB.start()
 
         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,7 +205,7 @@ 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.includes(peerA)
         })
         void psB.publish(topic, data)
 
@@ -219,17 +232,15 @@ 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], registrarA, registrarB, peerA, peerB)
 
         let subscribedTopics = psA.getTopics()
         expect(subscribedTopics).to.not.include(topic)
@@ -248,7 +259,7 @@ 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.includes(peerA)
         })
         void psB.publish(topic, data)
 
@@ -269,15 +280,12 @@ 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], registrarA, registrarB, peerA, peerB)
 
         // wait for remoteLibp2p to know about libp2p subscription
         await pWaitFor(() => {
           const subscribedPeers = psB.getSubscribers(topic)
-          return subscribedPeers.includes(psAid)
+          return subscribedPeers.includes(peerA)
         })
 
         void psB.publish(topic, data)
@@ -285,7 +293,7 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
         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,16 +335,14 @@ 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], registrarA, registrarB, peerA, peerB)
 
         // 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).includes(peerA)
         })
 
         // Verify messages go both ways

package/src/pubsub/emit-self.ts

@@ -2,20 +2,26 @@ import { expect } from 'aegir/utils/chai.js'
 import sinon from 'sinon'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import type { TestSetup } from '../index.js'
-import type { PubSub, PubsubOptions } from '@libp2p/interfaces/pubsub'
+import type { PubSub, PubSubOptions } from '@libp2p/interfaces/pubsub'
 import type { EventMap } from './index.js'
+import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+import { mockRegistrar } from '../mocks/registrar.js'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
 const shouldNotHappen = () => expect.fail()
 
-export default (common: TestSetup<PubSub<EventMap>, Partial<PubsubOptions>>) => {
+export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
   describe('emit self', () => {
     let pubsub: PubSub<EventMap>
 
     describe('enabled', () => {
       before(async () => {
-        pubsub = await common.setup({ emitSelf: true })
+        pubsub = await common.setup({
+          peerId: await createEd25519PeerId(),
+          registrar: mockRegistrar(),
+          emitSelf: true
+        })
       })
 
       before(async () => {
@@ -42,7 +48,11 @@ export default (common: TestSetup<PubSub<EventMap>, Partial<PubsubOptions>>) =>
 
     describe('disabled', () => {
       before(async () => {
-        pubsub = await common.setup({ emitSelf: false })
+        pubsub = await common.setup({
+          peerId: await createEd25519PeerId(),
+          registrar: mockRegistrar(),
+          emitSelf: false
+        })
       })
 
       before(async () => {

package/src/pubsub/index.ts

@@ -5,9 +5,9 @@ import connectionHandlersTest from './connection-handlers.js'
 import twoNodesTest from './two-nodes.js'
 import multipleNodesTest from './multiple-nodes.js'
 import type { TestSetup } from '../index.js'
-import type { PubSub, Message, PubsubEvents } from '@libp2p/interfaces/pubsub'
+import type { PubSub, Message, PubSubEvents, PubSubOptions } from '@libp2p/interfaces/pubsub'
 
-export interface EventMap extends PubsubEvents {
+export interface EventMap extends PubSubEvents {
   'topic': CustomEvent<Message>
   'foo': CustomEvent<Message>
   'test-topic': CustomEvent<Message>
@@ -15,7 +15,7 @@ export interface EventMap extends PubsubEvents {
   'Z': CustomEvent<Message>
 }
 
-export default (common: TestSetup<PubSub<EventMap>>) => {
+export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
   describe('interface-pubsub compliance tests', () => {
     apiTest(common)
     emitSelfTest(common)