@libp2p/interface-compliance-tests 1.1.6 → 1.1.10

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
         })

package/src/pubsub/emit-self.ts

@@ -1,21 +1,29 @@
 import { expect } from 'aegir/utils/chai.js'
 import sinon from 'sinon'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+import { mockRegistrar } from '../mocks/registrar.js'
+import { CustomEvent } from '@libp2p/interfaces'
 import type { TestSetup } from '../index.js'
-import type { PubSub, PubsubOptions } from '@libp2p/interfaces/pubsub'
+import type { PubSubOptions } from '@libp2p/interfaces/pubsub'
 import type { EventMap } from './index.js'
+import type { PubsubBaseProtocol } from '@libp2p/pubsub'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
 const shouldNotHappen = () => expect.fail()
 
-export default (common: TestSetup<PubSub<EventMap>, Partial<PubsubOptions>>) => {
+export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>) => {
   describe('emit self', () => {
-    let pubsub: PubSub<EventMap>
+    let pubsub: PubsubBaseProtocol<EventMap>
 
     describe('enabled', () => {
       before(async () => {
-        pubsub = await common.setup({ emitSelf: true })
+        pubsub = await common.setup({
+          peerId: await createEd25519PeerId(),
+          registrar: mockRegistrar(),
+          emitSelf: true
+        })
       })
 
       before(async () => {
@@ -34,7 +42,7 @@ export default (common: TestSetup<PubSub<EventMap>, Partial<PubsubOptions>>) =>
           once: true
         }))
 
-        void pubsub.publish(topic, data)
+        void pubsub.dispatchEvent(new CustomEvent(topic, { detail: data }))
 
         return await promise
       })
@@ -42,7 +50,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 () => {
@@ -61,7 +73,7 @@ export default (common: TestSetup<PubSub<EventMap>, Partial<PubsubOptions>>) =>
           once: true
         })
 
-        void pubsub.publish(topic, data)
+        void pubsub.dispatchEvent(new CustomEvent(topic, { detail: data }))
 
         // Wait 1 second to guarantee that self is not noticed
         return await new Promise((resolve) => setTimeout(resolve, 1000))

package/src/pubsub/index.ts

@@ -5,17 +5,20 @@ 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 { Message, PubSubEvents, PubSubOptions } from '@libp2p/interfaces/pubsub'
+import type { PubsubBaseProtocol } from '@libp2p/pubsub'
 
-export interface EventMap extends PubsubEvents {
+export interface EventMap extends PubSubEvents {
   'topic': CustomEvent<Message>
   'foo': CustomEvent<Message>
   'test-topic': CustomEvent<Message>
   'reconnect-channel': CustomEvent<Message>
   'Z': CustomEvent<Message>
+  'Za': CustomEvent<Message>
+  'Zb': CustomEvent<Message>
 }
 
-export default (common: TestSetup<PubSub<EventMap>>) => {
+export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>) => {
   describe('interface-pubsub compliance tests', () => {
     apiTest(common)
     emitSelfTest(common)