@libp2p/interface-compliance-tests 1.1.7 → 1.1.11

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)

package/src/pubsub/messages.ts

@@ -1,23 +1,33 @@
 import { expect } from 'aegir/utils/chai.js'
 import sinon from 'sinon'
-import * as PeerIdFactory from '@libp2p/peer-id-factory'
+import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import * as utils from '@libp2p/pubsub/utils'
+import { noSignMsgId } from '@libp2p/pubsub/utils'
 import { PeerStreams } from '@libp2p/pubsub/peer-streams'
+import { mockRegistrar } from '../mocks/registrar.js'
+import pDefer from 'p-defer'
+import delay from 'delay'
+import pWaitFor from 'p-wait-for'
+import { CustomEvent } from '@libp2p/interfaces'
 import type { TestSetup } from '../index.js'
-import type { PubSub } from '@libp2p/interfaces/pubsub'
+import type { PubSubOptions, RPC } from '@libp2p/interfaces/pubsub'
 import type { EventMap } from './index.js'
+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('messages', () => {
-    let pubsub: PubSub<EventMap>
+    let pubsub: PubsubBaseProtocol<EventMap>
 
     // Create pubsub router
     beforeEach(async () => {
-      pubsub = await common.setup()
+      pubsub = await common.setup({
+        peerId: await createEd25519PeerId(),
+        registrar: mockRegistrar(),
+        emitSelf: true
+      })
       await pubsub.start()
     })
 
@@ -29,83 +39,88 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
 
     it('should emit normalized signed messages on publish', async () => {
       pubsub.globalSignaturePolicy = 'StrictSign'
-      // @ts-expect-error protected field
-      sinon.spy(pubsub, '_emitMessage')
 
-      await pubsub.publish(topic, data)
-      // @ts-expect-error protected field
-      expect(pubsub._emitMessage.callCount).to.eql(1)
-      // @ts-expect-error protected field
-      const [messageToEmit] = pubsub._emitMessage.getCall(0).args
+      const spy = sinon.spy(pubsub, 'publishMessage')
+
+      await pubsub.dispatchEvent(new CustomEvent(topic, { detail: data }))
+
+      await pWaitFor(async () => {
+        return spy.callCount === 1
+      })
+
+      expect(spy).to.have.property('callCount', 1)
+
+      const [from, messageToEmit] = spy.getCall(0).args
 
+      expect(from.toString()).to.equal(pubsub.peerId.toString())
       expect(messageToEmit.seqno).to.not.eql(undefined)
       expect(messageToEmit.key).to.not.eql(undefined)
       expect(messageToEmit.signature).to.not.eql(undefined)
     })
 
     it('should drop unsigned messages', async () => {
-      // @ts-expect-error protected field
-      sinon.spy(pubsub, '_emitMessage')
-      // @ts-expect-error protected field
-      sinon.spy(pubsub, '_publish')
+      const publishSpy = sinon.spy(pubsub, 'publishMessage')
       sinon.spy(pubsub, 'validate')
 
       const peerStream = new PeerStreams({
-        id: await PeerIdFactory.createEd25519PeerId(),
+        id: await createEd25519PeerId(),
         protocol: 'test'
       })
-      const rpc = {
+      const rpc: RPC = {
         subscriptions: [],
-        msgs: [{
-          receivedFrom: peerStream.id.toString(),
+        messages: [{
           from: peerStream.id.toBytes(),
           data,
-          seqno: utils.randomSeqno(),
-          topicIDs: [topic]
+          seqno: await noSignMsgId(data),
+          topic: topic
         }]
       }
 
       pubsub.subscribe(topic)
-      // @ts-expect-error protected field
-      await pubsub._processRpc(peerStream.id.toString(), peerStream, rpc)
 
-      expect(pubsub.validate).to.have.property('callCount', 1)
-      // @ts-expect-error protected field
-      expect(pubsub._emitMessage).to.have.property('called', false)
-      // @ts-expect-error protected field
-      expect(pubsub._publish).to.have.property('called', false)
+      await pubsub.processRpc(peerStream.id, peerStream, rpc)
+
+      // message should not be delivered
+      await delay(1000)
+
+      expect(publishSpy).to.have.property('called', false)
     })
 
     it('should not drop unsigned messages if strict signing is disabled', async () => {
       pubsub.globalSignaturePolicy = 'StrictNoSign'
-      // @ts-expect-error protected field
-      sinon.spy(pubsub, '_emitMessage')
-      // @ts-expect-error protected field
-      sinon.spy(pubsub, '_publish')
+
+      const publishSpy = sinon.spy(pubsub, 'publishMessage')
       sinon.spy(pubsub, 'validate')
 
       const peerStream = new PeerStreams({
-        id: await PeerIdFactory.createEd25519PeerId(),
+        id: await createEd25519PeerId(),
         protocol: 'test'
       })
 
-      const rpc = {
+      const rpc: RPC = {
         subscriptions: [],
-        msgs: [{
+        messages: [{
+          from: peerStream.id.toBytes(),
           data,
-          topicIDs: [topic]
+          topic
         }]
       }
 
       pubsub.subscribe(topic)
-      // @ts-expect-error protected field
-      await pubsub._processRpc(peerStream.id.toString(), peerStream, rpc)
+
+      const deferred = pDefer()
+
+      pubsub.addEventListener(topic, () => {
+        deferred.resolve()
+      })
+
+      await pubsub.processRpc(peerStream.id, peerStream, rpc)
+
+      // await message delivery
+      await deferred.promise
 
       expect(pubsub.validate).to.have.property('callCount', 1)
-      // @ts-expect-error protected field
-      expect(pubsub._emitMessage).to.have.property('called', 1)
-      // @ts-expect-error protected field
-      expect(pubsub._publish).to.have.property('called', 1)
+      expect(publishSpy).to.have.property('callCount', 1)
     })
   })
 }