@libp2p/interface-compliance-tests 1.1.14 → 1.1.17

package/src/mocks/upgrader.ts

@@ -1,36 +1,46 @@
 import { expect } from 'aegir/utils/chai.js'
 import { mockConnection } from './connection.js'
-import type { Upgrader, MultiaddrConnection } from '@libp2p/interfaces/transport'
+import type { Upgrader, MultiaddrConnection, UpgraderEvents } from '@libp2p/interfaces/transport'
 import type { Registrar } from '@libp2p/interfaces/registrar'
+import { EventEmitter } from '@libp2p/interfaces'
 
-export interface MockUpgraderOptions {
+export interface MockUpgraderInit {
   registrar?: Registrar
 }
 
-export function mockUpgrader (options: MockUpgraderOptions = {}) {
-  const ensureProps = (multiaddrConnection: MultiaddrConnection) => {
-    ['sink', 'source', 'remoteAddr', 'timeline', 'close'].forEach(prop => {
-      expect(multiaddrConnection).to.have.property(prop)
+function ensureProps (multiaddrConnection: MultiaddrConnection) {
+  ['sink', 'source', 'remoteAddr', 'timeline', 'close'].forEach(prop => {
+    expect(multiaddrConnection).to.have.property(prop)
+  })
+  return multiaddrConnection
+}
+
+class MockUpgrader extends EventEmitter<UpgraderEvents> implements Upgrader {
+  private readonly registrar?: Registrar
+
+  constructor (init: MockUpgraderInit = {}) {
+    super()
+
+    this.registrar = init.registrar
+  }
+
+  async upgradeOutbound (multiaddrConnection: MultiaddrConnection) {
+    ensureProps(multiaddrConnection)
+    return mockConnection(multiaddrConnection, {
+      direction: 'outbound',
+      registrar: this.registrar
     })
-    return multiaddrConnection
   }
 
-  const upgrader: Upgrader = {
-    async upgradeOutbound (multiaddrConnection) {
-      ensureProps(multiaddrConnection)
-      return mockConnection(multiaddrConnection, {
-        direction: 'outbound',
-        registrar: options.registrar
-      })
-    },
-    async upgradeInbound (multiaddrConnection) {
-      ensureProps(multiaddrConnection)
-      return mockConnection(multiaddrConnection, {
-        direction: 'inbound',
-        registrar: options.registrar
-      })
-    }
+  async upgradeInbound (multiaddrConnection: MultiaddrConnection) {
+    ensureProps(multiaddrConnection)
+    return mockConnection(multiaddrConnection, {
+      direction: 'inbound',
+      registrar: this.registrar
+    })
   }
+}
 
-  return upgrader
+export function mockUpgrader (init: MockUpgraderInit = {}) {
+  return new MockUpgrader(init)
 }

package/src/pubsub/api.ts

@@ -8,15 +8,16 @@ 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, 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'
+import type { PubSub } from '@libp2p/interfaces/pubsub'
+import type { EventMap, PubSubArgs } from './index.js'
+import type { Registrar } from '@libp2p/interfaces/registrar'
+import type { PubSubBaseProtocol } from '@libp2p/pubsub'
+import { Components } from '@libp2p/interfaces/components'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
 
-export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>) => {
+export default (common: TestSetup<PubSubBaseProtocol<EventMap>, PubSubArgs>) => {
   describe('pubsub api', () => {
     let pubsub: PubSub<EventMap>
     let registrar: Registrar
@@ -26,9 +27,13 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
       registrar = mockRegistrar()
 
       pubsub = await common.setup({
-        peerId: await createEd25519PeerId(),
-        registrar,
-        emitSelf: true
+        components: new Components({
+          peerId: await createEd25519PeerId(),
+          registrar
+        }),
+        init: {
+          emitSelf: true
+        }
       })
     })
 
@@ -75,7 +80,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
       await pWaitFor(() => pubsub.getTopics().length === 0)
 
       // Publish to guarantee the handler is not called
-      pubsub.dispatchEvent(new CustomEvent(topic, { detail: data }))
+      pubsub.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
 
       // handlers are called async
       await delay(100)
@@ -93,7 +98,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         expect(msg).to.not.eql(undefined)
         defer.resolve()
       })
-      pubsub.dispatchEvent(new CustomEvent(topic, { detail: data }))
+      pubsub.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
       await defer.promise
 
       await pubsub.stop()

package/src/pubsub/connection-handlers.ts

@@ -8,16 +8,17 @@ 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 { 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<PubsubBaseProtocol<EventMap>, PubSubOptions>) => {
+import type { Message } from '@libp2p/interfaces/pubsub'
+import type { EventMap, PubSubArgs } from './index.js'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { Registrar } from '@libp2p/interfaces/registrar'
+import type { PubSubBaseProtocol } from '@libp2p/pubsub'
+import { Components } from '@libp2p/interfaces/components'
+
+export default (common: TestSetup<PubSubBaseProtocol<EventMap>, PubSubArgs>) => {
   describe('pubsub connection handlers', () => {
-    let psA: PubsubBaseProtocol<EventMap>
-    let psB: PubsubBaseProtocol<EventMap>
+    let psA: PubSubBaseProtocol<EventMap>
+    let psB: PubSubBaseProtocol<EventMap>
     let peerA: PeerId
     let peerB: PeerId
     let registrarA: Registrar
@@ -33,12 +34,18 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         registrarB = mockRegistrar()
 
         psA = await common.setup({
-          peerId: peerA,
-          registrar: registrarA
+          components: new Components({
+            peerId: peerA,
+            registrar: registrarA
+          }),
+          init: {}
         })
         psB = await common.setup({
-          peerId: peerB,
-          registrar: registrarB
+          components: new Components({
+            peerId: peerB,
+            registrar: registrarB
+          }),
+          init: {}
         })
 
         // Start pubsub
@@ -97,8 +104,8 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
     })
 
     describe('pubsub started before connect', () => {
-      let psA: PubsubBaseProtocol<EventMap>
-      let psB: PubsubBaseProtocol<EventMap>
+      let psA: PubSubBaseProtocol<EventMap>
+      let psB: PubSubBaseProtocol<EventMap>
       let peerA: PeerId
       let peerB: PeerId
       let registrarA: Registrar
@@ -113,12 +120,18 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         registrarB = mockRegistrar()
 
         psA = await common.setup({
-          peerId: peerA,
-          registrar: registrarA
+          components: new Components({
+            peerId: peerA,
+            registrar: registrarA
+          }),
+          init: {}
         })
         psB = await common.setup({
-          peerId: peerB,
-          registrar: registrarB
+          components: new Components({
+            peerId: peerB,
+            registrar: registrarB
+          }),
+          init: {}
         })
 
         await psA.start()
@@ -177,15 +190,15 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
           const subscribedPeers = psB.getSubscribers(topic)
           return subscribedPeers.map(p => p.toString()).includes(peerA.toString())
         })
-        void psB.dispatchEvent(new CustomEvent(topic, { detail: data }))
+        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
 
         await defer.promise
       })
     })
 
     describe('pubsub started after connect', () => {
-      let psA: PubsubBaseProtocol<EventMap>
-      let psB: PubsubBaseProtocol<EventMap>
+      let psA: PubSubBaseProtocol<EventMap>
+      let psB: PubSubBaseProtocol<EventMap>
       let peerA: PeerId
       let peerB: PeerId
       let registrarA: Registrar
@@ -200,12 +213,18 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         registrarB = mockRegistrar()
 
         psA = await common.setup({
-          peerId: peerA,
-          registrar: registrarA
+          components: new Components({
+            peerId: peerA,
+            registrar: registrarA
+          }),
+          init: {}
         })
         psB = await common.setup({
-          peerId: peerB,
-          registrar: registrarB
+          components: new Components({
+            peerId: peerB,
+            registrar: registrarB
+          }),
+          init: {}
         })
       })
 
@@ -275,15 +294,15 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
           const subscribedPeers = psB.getSubscribers(topic)
           return subscribedPeers.map(p => p.toString()).includes(peerA.toString())
         })
-        void psB.dispatchEvent(new CustomEvent(topic, { detail: data }))
+        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
 
         await defer.promise
       })
     })
 
     describe('pubsub with intermittent connections', () => {
-      let psA: PubsubBaseProtocol<EventMap>
-      let psB: PubsubBaseProtocol<EventMap>
+      let psA: PubSubBaseProtocol<EventMap>
+      let psB: PubSubBaseProtocol<EventMap>
       let peerA: PeerId
       let peerB: PeerId
       let registrarA: Registrar
@@ -298,12 +317,18 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         registrarB = mockRegistrar()
 
         psA = await common.setup({
-          peerId: peerA,
-          registrar: registrarA
+          components: new Components({
+            peerId: peerA,
+            registrar: registrarA
+          }),
+          init: {}
         })
         psB = await common.setup({
-          peerId: peerB,
-          registrar: registrarB
+          components: new Components({
+            peerId: peerB,
+            registrar: registrarB
+          }),
+          init: {}
         })
 
         await psA.start()
@@ -354,7 +379,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
           const subscribedPeers = psB.getSubscribers(topic)
           return subscribedPeers.map(p => p.toString()).includes(peerA.toString())
         })
-        void psB.dispatchEvent(new CustomEvent(topic, { detail: data }))
+        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
 
         await defer1.promise
 
@@ -387,7 +412,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
           return subscribedPeers.toString().includes(peerA.toString())
         })
 
-        void psB.dispatchEvent(new CustomEvent(topic, { detail: data }))
+        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
 
         await defer2.promise
       })
@@ -451,8 +476,8 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         })
 
         // Verify messages go both ways
-        void psA.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('message-from-a-1') }))
-        void psB.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('message-from-b-1') }))
+        void psA.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('message-from-a-1') }))
+        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('message-from-b-1') }))
         await pWaitFor(() => {
           return aReceivedFirstMessageFromB && bReceivedFirstMessageFromA
         })
@@ -465,8 +490,8 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         await pWaitFor(() => psAConnUpdateSpy.callCount === 1)
 
         // Verify messages go both ways after the disconnect
-        void psA.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('message-from-a-2') }))
-        void psB.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('message-from-b-2') }))
+        void psA.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('message-from-a-2') }))
+        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('message-from-b-2') }))
         await pWaitFor(() => {
           return aReceivedSecondMessageFromB && bReceivedSecondMessageFromA
         })

package/src/pubsub/emit-self.ts

@@ -5,24 +5,28 @@ 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 { PubSubOptions } from '@libp2p/interfaces/pubsub'
-import type { EventMap } from './index.js'
-import type { PubsubBaseProtocol } from '@libp2p/pubsub'
+import type { EventMap, PubSubArgs } from './index.js'
+import type { PubSubBaseProtocol } from '@libp2p/pubsub'
+import { Components } from '@libp2p/interfaces/components'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
 const shouldNotHappen = () => expect.fail()
 
-export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>) => {
+export default (common: TestSetup<PubSubBaseProtocol<EventMap>, PubSubArgs>) => {
   describe('emit self', () => {
-    let pubsub: PubsubBaseProtocol<EventMap>
+    let pubsub: PubSubBaseProtocol<EventMap>
 
     describe('enabled', () => {
       before(async () => {
         pubsub = await common.setup({
-          peerId: await createEd25519PeerId(),
-          registrar: mockRegistrar(),
-          emitSelf: true
+          components: new Components({
+            peerId: await createEd25519PeerId(),
+            registrar: mockRegistrar()
+          }),
+          init: {
+            emitSelf: true
+          }
         })
       })
 
@@ -42,7 +46,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
           once: true
         }))
 
-        void pubsub.dispatchEvent(new CustomEvent(topic, { detail: data }))
+        void pubsub.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
 
         return await promise
       })
@@ -51,9 +55,13 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
     describe('disabled', () => {
       before(async () => {
         pubsub = await common.setup({
-          peerId: await createEd25519PeerId(),
-          registrar: mockRegistrar(),
-          emitSelf: false
+          components: new Components({
+            peerId: await createEd25519PeerId(),
+            registrar: mockRegistrar()
+          }),
+          init: {
+            emitSelf: false
+          }
         })
       })
 
@@ -73,7 +81,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
           once: true
         })
 
-        void pubsub.dispatchEvent(new CustomEvent(topic, { detail: data }))
+        void pubsub.dispatchEvent(new CustomEvent<Uint8Array>(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,8 +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 { Message, PubSubEvents, PubSubOptions } from '@libp2p/interfaces/pubsub'
-import type { PubsubBaseProtocol } from '@libp2p/pubsub'
+import type { Message, PubSubEvents, PubSubInit } from '@libp2p/interfaces/pubsub'
+import type { PubSubBaseProtocol } from '@libp2p/pubsub'
+import type { Components } from '@libp2p/interfaces/components'
 
 export interface EventMap extends PubSubEvents {
   'topic': CustomEvent<Message>
@@ -18,7 +19,12 @@ export interface EventMap extends PubSubEvents {
   'Zb': CustomEvent<Message>
 }
 
-export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>) => {
+export interface PubSubArgs {
+  components: Components
+  init: PubSubInit
+}
+
+export default (common: TestSetup<PubSubBaseProtocol<EventMap>, PubSubArgs>) => {
   describe('interface-pubsub compliance tests', () => {
     apiTest(common)
     emitSelfTest(common)

package/src/pubsub/messages.ts

@@ -10,23 +10,32 @@ import delay from 'delay'
 import pWaitFor from 'p-wait-for'
 import { CustomEvent } from '@libp2p/interfaces'
 import type { TestSetup } from '../index.js'
-import type { PubSubOptions, RPC } from '@libp2p/interfaces/pubsub'
-import type { EventMap } from './index.js'
-import type { PubsubBaseProtocol } from '@libp2p/pubsub'
+import type { PubSubRPC } from '@libp2p/interfaces/pubsub'
+import type { EventMap, PubSubArgs } from './index.js'
+import type { PubSubBaseProtocol } from '@libp2p/pubsub'
+import { Components } from '@libp2p/interfaces/components'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
 
-export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>) => {
+export default (common: TestSetup<PubSubBaseProtocol<EventMap>, PubSubArgs>) => {
   describe('messages', () => {
-    let pubsub: PubsubBaseProtocol<EventMap>
+    let peerId: PeerId
+    let pubsub: PubSubBaseProtocol<EventMap>
 
     // Create pubsub router
     beforeEach(async () => {
+      peerId = await createEd25519PeerId()
+
       pubsub = await common.setup({
-        peerId: await createEd25519PeerId(),
-        registrar: mockRegistrar(),
-        emitSelf: true
+        components: new Components({
+          peerId,
+          registrar: mockRegistrar()
+        }),
+        init: {
+          emitSelf: true
+        }
       })
       await pubsub.start()
     })
@@ -42,7 +51,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
 
       const spy = sinon.spy(pubsub, 'publishMessage')
 
-      await pubsub.dispatchEvent(new CustomEvent(topic, { detail: data }))
+      await pubsub.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
 
       await pWaitFor(async () => {
         return spy.callCount === 1
@@ -52,8 +61,8 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
 
       const [from, messageToEmit] = spy.getCall(0).args
 
-      expect(from.toString()).to.equal(pubsub.peerId.toString())
-      expect(messageToEmit.seqno).to.not.eql(undefined)
+      expect(from.toString()).to.equal(peerId.toString())
+      expect(messageToEmit.sequenceNumber).to.not.eql(undefined)
       expect(messageToEmit.key).to.not.eql(undefined)
       expect(messageToEmit.signature).to.not.eql(undefined)
     })
@@ -66,12 +75,12 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         id: await createEd25519PeerId(),
         protocol: 'test'
       })
-      const rpc: RPC = {
+      const rpc: PubSubRPC = {
         subscriptions: [],
         messages: [{
           from: peerStream.id.toBytes(),
           data,
-          seqno: await noSignMsgId(data),
+          sequenceNumber: await noSignMsgId(data),
           topic: topic
         }]
       }
@@ -97,7 +106,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         protocol: 'test'
       })
 
-      const rpc: RPC = {
+      const rpc: PubSubRPC = {
         subscriptions: [],
         messages: [{
           from: peerStream.id.toBytes(),